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!)