This topic mentions IMHO an important point: D is not only
interesting for C++ people, but also for Java developers.
Companies that are happy with Java may have little incentive to
change to D or maybe Go. But when starting something new D can be
an alternative to Java as it also can be used for application
development to some extend (has a GC, fast build times and other
things that result in good productivity). Someone like me who has
spent his career with Smalltalk and Java and doesn't know a thing
about systems programming can get along with D quite easily.
Something like a "D for Java developers" user guide would make
sense IMHO.
D has better performance than Java and better productivity than
C++. Java is starting to get polluted with several things like
dependency on XML which really degrades productivity. I don't
spend my time looking for bugs in source code, but in XML
definition files (every framework has XML, some even allow you to
define logic in XML like Apache Camel). And this takes much more
time than when looking into code.
Then Java suffers from its threading model which is suitable for
general purpose programming, but not for web applications. For
WhatsApp a single machine holds over a million network
connections (see
https://www.erlang-solutions.com/about/news/erlang-powered-whatsapp-exceeds-200-million-monthly-users)
due to Erlang's threading model being able to get this
accomplished. In Go more than 100k network connections is also
not a problem (according to some tweet by Rob Pike). What seems
to attract people to Go is Go's threading model that is very well
suited for network programming and server-side web development.
But Go's language is simplistic and that probable won't change.
My impression is that this is on purpose. They want a modernized
C and that's it. So there is room for D here for server-side
development à la Go but with a high-level language. There is
really hell going on in Go's user forum. Multi-threading and
concurrency through goroutines as well as good libraries for
network programming seem to be the driving factors for Go.
D is really modelling power as well. That's the big win over Go.
No Java/EE architect will accept a language without inheritance
nor method overriding. I think there is no feature in Scala that
D doesn't have (except implicits, which is a good thing not to
have). On the contrary D has immutable types and pure functions.
Things that aren't possible in Scala due to limitations of the
JVM or need for interoperability.
-- Bienlein
