Andrei writes "The Case for D"

[grauzone]

Walter Bright wrote:
> http://www.reddit.com/r/programming/comments/8stcr/the_case_for_d/

Nice article. Here some random bitching.

 > If you are patient, you'll find out that D has constructors and 
destructors with which you can implement deterministic lifetime of objects.

Not entirely true. Andrei forgot that destructors, in many situations, 
are not deterministic at all, because the garbage collector calls the 
destructor when an object is finalized. Another easily fixable mistake 
that makes life so hard.

 > Other implementations are underway, notably including an a .NET port 
and one using the LLVM infrastructure as backend.

Just that LDC (why not mention it directly?) is starting to become more 
stable than DMD, while the .NET port is in an early alpha stage at best.

 > In fact, D can link and call C functions directly with no intervening 
translation layer.

Sure, but that makes the uninformed reader think he can use header files 
directly. He will be disappointed when he finds out he has to translate 
headers manually. (AFAIK there's no tool yet which does this 
automatically with no user intervention required.)

 > This low latency means you can use D as a heck of an interpreter (the 
shebang notation is supported, too).

Now isn't that quite implementation specific. Maybe you should also 
mention that dmd is not only fast, but also contains lots of bugs that 
become issues in real life. So much for the implementation of the 
reference compiler. (And sure, no doubt any language is easier to parse 
and compile than C++. You could claim dmd's fastness is only a special 
thing when compared to C++.)

 > The basic idea is that D allows you to subtype as you need via alias 
this.

Oh, so you decided to keep it.

 > Variable-length parameter lists are also allowed.

Just not variable-length alias parameter lists or variable-length lists 
of constants, d'oh.

 > What takes things into space is the ability to convert strings into 
code (by use of the mixin expression).

I think the reader won't understand at all what's going on. Why not 
provide a simple example? int y = 1; int x = mixin("2+y");

 > A better design has been blueprinted and the implementation is "on 
the list," so please stay tuned for more about that.

(That was about reflection.) I think the readers of the newsgroup, where 
future directions of D 2.0 are regularly discussed, would like to know 
more about this.

 > In D, the Boolean compile-time expression is(typeof(expr)) yields 
true if expr is a valid expression, and false otherwise (without 
aborting compilation).

Surprised to find this anti-feature mentioned in an introductory article 
on D.