Interesting Observation from JAXLondon

[Russel Winder]

On Thu, 2018-10-11 at 13:00 +0000, bachmeier via Digitalmars-d wrote:
[…]
> Suggestions?
> 
> My guess is that the reason they've heard of those languages is 
> because their developers were writing small projects using Go and 
> Rust, but not D.

I fear it may already be too late. Go, and now Rust, got marketing hype from
an organisation putting considerable resources into the projects. This turned
into effort from the community that increased rapidly, turning the hype into
frameworks and libraries, and word of mouth marketing. It is the libraries and
frameworks that make for traction. Now the hype is gone, Go and Rust, and
their libraries and frameworks, are well positioned and with significant
penetration into the minds of developers.

Talk to Java developers and they have heard of Go and Rust, but not D. Go is
more likely to them because of Docker and the context of The Web, for which Go
has a strong pitch. They have heard of Rust but usually see it as not relevant
to them, despite Firefox.  
 
Talk to Python developers and they know of Go, many of them of Rust, but
almost never D. C and C++ are seen as the languages of performance extensions,
though Rust increasingly has a play there.

D has vibe.d, PyD, GtkD, and lots of other bits, but they've never quite had
the resources of the equivalents in Go and Rust.

Also the D community as a whole is effectively introvert, whereas Go and Rust
communities have been quite extrovert. "Build it and they will come" just
doesn't work, you have to be pushy and market stuff, often using guerilla
marketing, to get mindshare.

D has an excellent position against Python (for speed of development but
without the performance hit) but no chance of penetrating the places where
Python is strong due to lack of libraries and frameworks that people use – cf.
Pandas, SciKit.Learn, etc.

D has an excellent position against Go as a language except that Go has
goroutines and channels. The single threaded event loop and callback approach
is losing favour. Kotlin is introducing Kotlin Coroutines which is a step on
from the observables system of Rx. Structured concurrency abstracting away
from fibres and threadpools. Java may well get this via Project Loom which is 
Quasar being inserted into the JVM directly. Whatever D has it doesn't seem to
be going to compete in this space.

D without the GC has a sort of position against Rust, but I think that battle
has been lost. Rust has won in the "the new C that isn't Go and doesn't have a
garbage collector, and isn't C++, but does have all the nice monads stuff, oh
and memory safety mostly".

When it comes down to it D will carry on as a niche language loved by a few
unknown to most.

-- 
Russel.
===========================================
Dr Russel Winder      t: +44 20 7585 2200
41 Buckmaster Road    m: +44 7770 465 077
London SW11 1EN, UK   w: www.russel.org.uk

-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 833 bytes
Desc: This is a digitally signed message part
URL: <http://lists.puremagic.com/pipermail/digitalmars-d/attachments/20181012/aa49c432/attachment.sig>