6 ms·
Does D have much of a use case left? Java and C# are statically typed, garbage collected languages with a huge adoption and massive amounts of tooling. D's at
by echelon 10y ago
Does D have much of a use case left?
Java and C# are statically typed, garbage collected languages with a huge adoption and massive amounts of tooling.
D's attempt to become an alternative to C and C++ was eclipsed by Rust, which doesn't have the GC overhead and has a ton of other really compelling features.
There are a bunch of other new and exciting languages too: Go, Nim, ...
Why would anyone choose D today? (Serious question.)
- jackmott 10y agoD is GC optional, so that makes it pretty different than Java and C# and Go. It also compiles to native exes as the normal procedure. You can do that with Java / C# in special cases though. D is much easier to pick up than Rust. Rust seems to take the runtime overhead of Java/C# and put it into your brain overhead during typing time. D has very fast compile times, Rust has very slow compile times.
- ruleabidinguser 10y agoI would like to use D if I could dump the GC, but it appears they don't make that easy, even though as you say it is possible. For me smart pointers make memory management seem not so daunting.
- bachmeier 10y agoIt's actually pretty easy. Just mark your code as @nogc, and it won't compile if there's anything that could potentially trigger a garbage collection. You obviously lose some functionality this way, but there's nothing difficult about avoiding the GC.
- mhh__ 10y agoThere are smart pointer libaries, and also implementing ref counting is much more straightforward than in C++ because the type system knows whether data is being shared or not. I should add that the GC actually works perfectly fine for normal work, it justs not up to the competition (Partly because of having to work with traditional dynamic memory).
- shakna 10y agoI wrote my thesis in D. I considered C/++, Rust, Go, Nim and D. D won because: * Less manual memory management * Awesome compile-time errors (this is absolutely key) * Super easy tooling setup * High-level abstractions in stdlib * Still reasonably fast * AOT compiled, which was a hard requirement for what I was researching
- dom96 10y agoInteresting. I'm curious in particular where Nim fell short, any chance you could elaborate?
- shakna 10y agoIt was in a rough time for Nim, around the transition from the old name, when the documentation was still being rewritten, and metaprogramming was a magic few knew or used. D and it's errors were just easier. Not to say Nim isn't on my radar for new things, it just didn't quite fit at the time. (However, my first prototype was in Nim!)
- dom96 10y agoMakes sense. Thank you for answering, is your thesis available for reading anywhere?
- shakna 10y agoAnytime. Unfortunately not, as I no longer have the right to publish it, and it hasn't appeared in the journal yet. But basically, partial evaluation of the AST to create a fully type-inferenced statically typed F-expr Lisp. Makes JITing faster.
- systems 10y agobut this is really a poor argument for D your thesis code, isn't necessarily code that will be used by many people or shared with many developer (you didnt even share a link to the source code) a thesis, just produce a proof of concept D is unpopular , and I really believe that going after c++ was a bad idea .. if this was not clear at first, it should be clear by now, yet almost 100% of the article i see on D never stop from claiming how much better it is compare to c++ I guess the lesson learned from D's unpopularity is, when creating something dont focus on one competing tool I recall how one time Linus Torvald, bashed subversion on how "Its goal is to be a mostly compatible successor to the widely used Concurrent Versions System" -- Wikipedia Was a horrible design choice from the start By focusing on C++ they added a GC, as an advantage (because C++ didnt have a GC) but now that many people priase Rust for not having a GC and arguing they prefer C++ over D for it ... now they are trying to dis-integrate the GC ... very reactive, design decision ... and i doubt this will help much
- Ace17 10y ago> D's attempt to become an alternative to C and C++ was eclipsed by Rust, which doesn't have the GC overhead and has a ton of other really compelling features. Rust isn't just a better C++, it imposes a new paradigm over resource management (lifetime oriented programming?). If you're coming from C++, you have to change your way of thinking. D doesn't try to make you follow any paradigm (for the better and for the worse) ; and its syntax will feel natural and terse for a C++ programmer. My experience (10 people team) has shown all C++ programmers can learn D very quickly. Is this the case for Rust? > Why would anyone choose D today? (Serious question.) Native speed, on-demand deterministic destruction, on-demand memory safety, metaprogramming, fast compile times, terse syntax.
- oddity 10y agoI'm tempted to think that Rust doesn't really impose a new paradigm over resource management so much as it standardizes and enforces the common conventions of C++ resource management. A major pain point probably is that people never really followed the "conventions" of C++ resource management as rigidly as Rust enforces them.
- lbrandy 10y ago> A major pain point probably is that people never really followed the "conventions" of C++ resource management as rigidly as Rust enforces them. That's exactly right. Rust does a great job moving idiomatic C++ best practices into the type system and actually forcing you to do it "right". And alot of the early pain people run into when switching to Rust is learning how to do this. I suspect very experienced C++ programmers have alot less challenge getting spun up on Rust. It's sorta front-loading the pain of discovering and learning C++'s best practices. As a side effect, though, it means alot of Rust evangelism misses the mark as it mostly reveals their own C++ weaknesses (this is, on a different level, an indictment of C++, and its learning curve, but not really in the ways the evangelists often believe).
- SamReidHughes 10y agoI'd amend this to say it's a subset of the C++ conventions.
- charles-salvia 10y agoWhile I kind of like D, it's hard to really make the case for using it. The thing is, it simply doesn't provide that much of a significant advantage over modern C++14/17 to make it worthwhile. At least Rust introduces an entirely innovative new concept with the borrow checker. D is just basically C++ with optional garbage collection and better syntax for meta programming, but without the vast Universe of existing C++ libraries to leverage.
- mhh__ 10y agoD compile times alone are an advantage. I should probably point out that D can actually do some (More than anyone else) C++ interop.
- destructionator 10y agoD also has nice opt-in reflection as an advantage over C++ (though there are C++ tools to make up for it, to an extent). The reflection is IMO the killer individual feature (well, hand-in-hand with the codegen to actually use it). The rest is just the benefit of 1000 small things that all add up to a greater whole.
- charles-salvia 10y agoYeah, automatic static reflection for serialization of standard-layout structs in C++ would certainly be nice. You can achieve something like that with std::tuple, but it's certainly not comparable to first-class serialization. PS, I used to enjoy your posts on SDN, before the site owner threw a fit. :-)
- Ace17 10y ago> D is just basically C++ with optional garbage collection and better syntax for meta programming, but without the vast Universe of existing C++ libraries to leverage. Phobos, the D standard library, makes C++ standard library look very small. C++14 standard library still can't do "ls", "execvp", "socket" in a portable way (but we finally got std::thread and std::function!). Phobos can do all of this, and also haves support for md5, gzip, diff, sort, getopt, json, xml, ... Thus the need for an external library is a lot less likely than it is in C or C++, and you almost never spend time rewrapping native stuff: it's already done by Phobos. And in the end, if you need to use some specialized library, D can call C and C++ functions with zero overhead (I have D projects that use CGAL and SDL).
- mhh__ 10y agoProductivity. D is a very pragmatic systems language. C++ interop is basically unparalleled, UFCS makes writing libraries less traumatic and CTFE is just plain useful. On top of this, the type system is both concurrency aware and has the best generics I've ever used (Subjective as it gets, but that's my experience). If you want safety guarantees just tag a scope as @safe. Also, static reflection works really well. Compiles(with DMD, ldc and gdc are still fast but are not as fast) are fast and D is not really comparable with Go (For example). D is much more complex (and I my opinion simpler to write through said complexity, but obviously opinions differ), whereas Go is supposed to be simple to learn and implement.
- rbehrends 10y ago> Java and C# are statically typed, garbage collected languages with a huge adoption and massive amounts of tooling. 1. Java and C# are designed around JIT compilation, which results in a number of architectural choices that may or may not be to your liking. 2. The JVM and CLR are pretty heavyweight pieces of machinery. 3. Neither Java nor C# are particularly well-suited for working "close to the metal". > D's attempt to become an alternative to C and C++ was eclipsed by Rust, which doesn't have the GC overhead and has a ton of other really compelling features. This goes both ways: Rust doesn't have a GC, so if you want one, you're out of luck. For example, for most of what I'm doing – where GC works fine –, Rust offers me no benefit, but significant costs (note that this is a matter of application domains: the ones that Rust is designed for are simply not ones that matter much to me). > There are a bunch of other new and exciting languages too: Go, Nim, ... Go and Nim are indeed the languages that D is competing with more directly, but there's nothing wrong with having competition in this area, given that all of them are relatively new.
- p0nce 10y agoIn my line of work (real-time), C++ typically reigns supreme but D is just as fast and more productive, so why not use it? It's not really about meta-programming, for me it wins on the basics. And is we talk meta-programming, I think D goes further in the Stepanov style: https://www.youtube.com/watch?v=LIb3L4vKZ7U https://www.youtube.com/watch?v=LIb3L4vKZ7U