D as a betterC a game changer ?

[Dan Partelly]

On Tuesday, 26 December 2017 at 19:34:35 UTC, Mike Franklin wrote:

> Rust is an example of a language that got it right.  It is 
> inherently memory-safe, can interface with legacy code 
> requiring essentially no runtime, and still has optional 
> reference counting, and plans for an optional garbage collector 
> [1].

I could not agree more with this. It is unfortunate D has 
dependencies on a garbage collector in language proper and in std.

Of course, only if it wants to go against C/C++, and the fact a 
-betterC exists suggests that it does. If it wants a place with 
Java/C# well, then all they have to do is to plug-in an 
industrial strength GC implementation and live happily ever after.

The situation is a bit weird today for an outsider like me. Make 
no mistake, outsider first impressions count , even if they 
contain errors. This is because the adoption of a language will 
rather be a function of social factors then technical excellence, 
as I mentioned before on this board

The D personality is mixed:

1. A language and a std depending on GC, but with an imprecise GC 
(do they really want that marginal speed ??) suggesting they want 
to go against Java like

2. Promoted as language which can be used with no GC (but 
practically you cannot, at least not easily because a lot of the 
core language depends on GC, and what is worst std depends on it 
too, and made the mistake to put hashes vectors and strings in 
language proper rather than lib ) . This marketing suggest they 
care about 0 cost abstractions , but they where an afterthought 
added when they realized they are useful. Which is weird since 
they also have second to none compatibility linking against C, 
which suggest they where aware of how important this whole 
business is.

3. Now seeing a -betterC mode, which is really 0 cost abstraction 
and delivers , but
removes from language what it should have been a library in the 
first place, without providing a library alternative from it and 
a crippled std.

All could have been prevented by going the C++ route of 0 cost 
abstraction, and have a stellar std which also offered a GC for 
those who want it. *ALL* language features could have been 
implemented in this mode.