Top 5

[Chad J]

Andrei Alexandrescu wrote:
> Ok, per Aarti's suggestion: without speaking officially for Walter, let 
> me ask this - what do you think are the top issues you'd like to see 
> fixed in D?
> 
> Andrei

OK.  Here, have a wall of text.

1. Tango and Phobos merge.  I'm with the others on this.  The few people 
I've introduced to D seem very irritated by the existence of 2 standard 
libs.  I think even a common runtime will be insufficient to calm the 
worries of newcomers, but it is a step in the right direction.  A single 
standard API is what needs to happen.

2. Walter working on an open compiler.  If Walter were to announce that 
he would be working on LLVMDC I would clench my fists and shout "FUCK 
YEAH!!".  That's because this would be really awesome and would pump me 
up; sort of like watching Gurren Lagann.  I think I might be a bit of an 
odd fellow, even by geek standards...

3. Forward references.  Even I've run into this a few times, and I can 
see how people can run into this a lot and how it would make their lives 
miserable.  This isn't quite a language issue as much as an 
implementation issue, but if you're looking for places to spend time 
then this is one of them.

4. The find-the-missing-parentheses game is not fun.  I avoid playing 
it.  Now let's make it easy for the unfortunate victi-, I mean newbies, 
to avoid playing this game.  Just get rid of D's implicit property 
syntax.  Walter seems opposed to explicit properties for whatever 
reason, so let's just not have properties.  This implicit property 
syntax gives us this trade-off: On the upshot, you save a few keystrokes 
every now and then.  On the downside, you get some horrible runtime bugs 
that take hours and hours to debug.  I'll give that one a miss.  So if 
it's too hard to do it right, then please don't do it at all.

5. 4 is all you get.  Sorry.

Notes:
4 may be a member of a broader category of language features: cute 
syntax sugary things that have the potential to cause really nasty bugs 
in people's code.  Oh hey, switch-case, so glad you could join us (but 
not really).
Also I'd like to hear an update on how Walter, and maybe you Andrei, 
feel about this implicit properties issue.  I remember in 07 Walter 
saying something to the effect that explicit properties were not a 
priority and that they weren't something with proven usefulness.  I'm 
realizing now why I'm not entirely convinced:  the current implicit 
properties cause nasty bugs, and getting rid of that possibility MUST be 
a good idea.  At that point, explicit properties aren't nearly as useful 
as removing implicit properties.  So, if you don't mind, what are the 
thoughts of the D designer(s) on this one?

On compilers, here are my observations:
- DMD is nice, but it only targets x86 Windows and Linux.  It will only 
ever support x86 Windows and Linux.  Want to target Macs? Nope.  How 
about 64-bit systems, namely the really good 64-bit linux systems that 
are around nowadays? nope. Cell phones? hahahaha.  ... to me this is a 
fatal flaw.  The fact that DMD has proprietary code in it doesn't help 
either.
- GDC.  It has the potential to target everything under the sun through 
shear brute force.  Of course, someone has to bother to make the runtime 
and the glue work for these other platforms.  Oh fun.  Now, this is 
still pretty cool, but then we consider how GDC rarely gets updates.  I 
use an SVN version of it nowadays--something I hardly ever do with 
software.  GDC just doesn't have much muscle behind it, and I can see 
why.  It's kind of like stereotypical sci-fi advanced high powered alien 
technology, only to use it you have to stick your hand into this horrid 
smelling sticky goopy stuff to use the controls.  But wait, there's 
more!  I've read that the GCC/GNU zealots won't let GDC into the fold 
without the frontend's copyright being assigned to the FSF.  Have fun 
guys.  It's still what I use though, because it can like, actually 
compile 64-bit programs for my 64-bit computer.  Awesome feature, really.
- LLVM.  I really wish the D frontend for this was fully functional. 
The license is nice, it has growing numerous backends, and it has a 
portable C backend.  That C backend means that even if you don't have a 
highly optimized backend for your platform already, you STILL win. 
Seriously wtf, it's broken.  OK, well there are still those damned Java 
phones, but maybe a Java bytecode backend would fix that issue.  It's 
like that gun you get towards the end of the game.  Up until now you've 
had a knife for when your sidearm runs out of bullets.  Now you're given 
this improved BFG9000-like thing that (1) kills everything on the screen 
(2) does it in one hit (3) does it repeatedly and quickly (4) doesn't 
run out of ammo.  There is only one right answer.  Oh and in our case we 
can have it early in the game.

Another thing came to my mind as well.
I think D is not strong as an experimental language.
I think D IS strong as a robust, high-productivity language.
I'm not too keen on numerous new nifty features.  Back when I got into 
D, I noted that D seemed to follow this idea of progressive disclosure 
as well as the principle of least surprise.  It wasn't the features that 
sold me.  It was this remarkable ease of use and general smoothness that 
sold me.  D is strong in that area, and I'd like to see D keep its 
strengths.  Of course, new features are always nice, but the good design 
principles that are in D's roots should take priority, IMHO.

If you read the whole thing, thank you for your time.  I do have this 
habit of rambling on.  Maybe you could tell.  But now I have a class to 
go to.

Later,
- Chad