In an ideal world, good programming languages would win or lose on their own merits, but that doesn't seem to be the case in the world we actually live in.
D is really nice and very effective, even for a soft real-time system like ours. Most of our code didn't do any GC but where we don't care too much we can make our life a little easier.
Well I suppose that depends on what you mean by "merits". D has struggled with things like IDE support and breaking changes. A lot of that is now cleared up or being worked on as the language has seen increased activity over the last few years. I expect remaining issues to get cleaned up in the near future.
Another thing that kept folks away was the garbage collector. Quite a lot of work is being done to make it possible to use as much of the language as possible without the GC. Nonetheless, for many potential users, fear of the GC was a reason to not use D.
from Walter's post: https://news.ycombinator.com/item?id=17192702
D might have been an important evolutionary step, possibly showing what does not work well for the niche it was trying to fill.
Support from a big corp is one way to get things like IDE support ironed out, as they can throw extra resources at it.
The RLS is used in VSCode, I think Atom, I’ve seen a port for Emacs, and I think Sublime.
The community effort is behind the RLS, the Jetbrains plugin for IntelliJ doesn’t use any of the Rust compiler, as far as I’m aware, but it does have a lot of fans, so they’re doing something right.
As a Java fan of IntelliJ, I still prefer the RLS+VSCode, but it’s great seeing all the IDEs being developed for Rust!
[1] I realize that this is not a universally held opinion, but it certainly seems to be pretty widely held.
I'm no expert in either Ada or Rust, but I _suspect_ that type system is more expressive in Rust, allowing for more precise static constraints.
Ada, of course, has decades of prod experience, though.
If you combine Ada with Spark you get some (still) amazing compile type proof checking of projects. [1]
Rust _could_ develop to have similar abilities (I hope!). But it’d need more generalized linear types or dependent types. Though one could write macros with stargeted higher level type checking DSL for, say, embedded development targets.
0: https://github.com/rust-lang/rfcs/issues/671 1: https://docs.adacore.com/spark2014-docs/html/ug/en/source/ty...
Plus, Rust has a thriving community whereas thanks to Adacore, Ada has a dying one. Community is critical for programming languages.
But otherwise, Ada is a brilliant and ultra safe language whose safety features go far beyond the memory and type safety that Rust features.
It's a shame.
It is the only Ada compiler available for free, fully updated to Ada 2012, with all the remaining ones are still on their 90's style prices.
https://www.ptc.com/en/products/developer-tools/objectada
https://www.ghs.com/products/ada_optimizing_compilers.html
https://www.ddci.com/products_score/ (frozen in Ada 95)
Thanks to them Ada has become a regular presence at FOSDEM and is being teached at quite a few European university.
Also Ada allows for compiler assisted runtime allocation. For example, you can declare a datastructure with the size you want, and if it fits the stack it will be allocated, otherwise you get an exception.
Deallocation C style requires the Uncheked_Deallocation package.
Ada 95 removed GC from the standard, as no compiler ever bothered to implement it.
Here is an overview presented at FOSDEM 2016.
https://archive.fosdem.org/2016/schedule/event/ada_memory/
With SPARK and Ada 2012, Ada allows for better security constraints than Rust.
"Real-Time Critical Systems: HRM Prototype & Ada Integration"
https://www.amazon.com/Real-Time-Critical-Systems-Prototype-...
They even have branding best practices and so on.
Of course, Google, being an advertisement company, has a lot of know how in that area.
Too bad Go is being held back by Rob Pike's ego, in my opinion.
Including compilation to WebAssembly as target.
Kotlin has reasonable compile times, GC of course, and also a reasonable concurrency story.
Go apparently has other special features, like making a single binary, and having very low-delay GC. Also, it's very simple; it's basically a pared-down Modula-2 with the Oberon's methods thrown in. It also got non-fitting magic features added, like returning two values (not a tuple), or built-in generic functions (like `make(chan)`) without generics anywhere else, etc. These do not fit well, which makes many people sad.
MSFT is also contributing to Haskell by supporting Haskell-related research, and employing Simon Peyton Jones.
Jane Street Capital is also heavily investing in OCaml.
While these languages are occupying a different niche than D, they are more arguably innovative/ integrate way more research / plt theory.