Why I Use D

[Scott S. McCoy]

I'll tell you what brings me to D.

I'm interested in business programming around event models in large
throughput applications.  What better environment than one which has
method references which retain their object scope, closures which retain
their references (although that only works in DMD currently and I mostly
use GDC, but I'm not missing it much just looking forward to it
working), what seems to be solid garbage collection and nice, expressive
programming at the system level...

The other interest I have, as it is the unfortunate reality of business
applications that many vendor libraries which are required for
integration just aren't meant for asynchronous applications (and for the
sake of scaling across multiple processing channels), is multithreadded
programming.  And when I first heard about const, I was excited.  When I
then looked into just how complex this topic has become, I got weary.

Some phase of D is just what I want in a programming language.  That
phase is somewhere in the middle of D 1.0 and D 2.0, where closures are
added and there weren't so many types of const/invariant behaviors and
syntaxes to figure out.  I like the idea of const, but I don't like the
idea of the language becoming inanely complex for the sake of trying to
solve a problem no other language is able to solve.

Personally, I think the immutability of a real const, read-only view, is
ideal.  The ability to return read-only references to a data structure
that isn't read only sounds like the compiler solving the never-ending
problem I've faced in java of programmers being too sloppy to properly
build immutable objects.

const fixes everything.  But what does invariant give me?  The way I see
it, it's just a way to qualify literal values for most purposes!  And
that I find unnecessary, because they may as well just implicitly be
const.  And theoretically, if const is really a read only view, once you
promote to const, you shouldn't be able to come back out of it.
Honestly, I don't see the reason for everything else...it makes sense to
qualify a method as "doesn't modify the object" so it can be accessible
from a const reference to that object, but 

I love the expressiveness that D has...and while I'm writing this, I'll
take a second to plug my thoughts on array slicing.

array[..] should be synonymous with array[0..$]
array[5..] should be synonymous with array[5..$]/array[5..length]
array[..5] should be synonymous with array[0..5].

This makes the language a little more expressive, makes sense, and
doesn't require $.

Cheers,
    Scott S. McCoy

On Fri, 2008-03-28 at 12:04 -0700, Russell Lewis wrote:

> lurker wrote:
> > I just love D and use nothing else anymore - if i can help it. 
> 
> I like this thread...griping is an easy trap to fall into.  Why do I use D?
> 
> * dynamic arrays
> * delegates, particularly now that closures work (very cool!)
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.puremagic.com/pipermail/digitalmars-d/attachments/20080328/718aa87d/attachment.html>