The D Language Front-End Merged Into GCC 9

It's been open source for 10 years now.

The only issue with the GC is the implementation could get some improvements.

Mesa/Cedar, Oberon and its variants, Modula-3, Sing# and System C# might have fallen, but we still have Swift, Go, .NET Native/C# 7.3, Kotlin/Native, Nim, Crystal and Chapel, besides D.

Not all hope is lost for those of us that belive on system languages with GC support.

I actually like that it has a GC, it has made programming in D easier and more accessible for me. It's also a simple GC that you can force to behave if you know how. D has the @nogc attribute for the situations where one would want to disable the GC and use something else.

https://dlang.org/blog/the-gc-series/

There's lots of great stuff for embedded in Rust now too, you can no_std and use core, the new panic stuff. IMO it's awesome to write a language and do some more 'advanced' type stuff like add compile time safety with phantom types and stuff have it compile and run on an embedded device. The interesection of features there is great.

I remember that - _many_ years ago, ten maybe? - when I tried to use D for OS development, I was forced to use GCC because it was the only one who supported custom linker scripts IIRC. Nice to see that all the projects are still doing well!

> Ain't it great to have a choice?

Not if it means that every choice is sub-par

As category theory teaches us, there is a duality to a choice. If you are constructing value of a sum type you can choose any variant, but the one who receives it should be able to handle any possible variant. If you are using a library you can choose any compiler, but author of that library should ensure that it works with all compilers. If someone has a choice, then in some other place there is more complexity or work to be able to handle that choice.

>Ain't it great to have a choice?

Not if the choice leads to duplication of effort, smaller community, feuds and conflicts, decision fatigue, and so on.

This is literally what stopped me from learning D a few years ago. I started reading about it, got intrigued, did some tutorial-style stuff, decided to try it on a real project, and then realize that meant having to figure out which toolchain or choice of standard lib to use, and just gave up and used c++ as usual.

If I was already familiar with the tradeoffs, or if I was very motived to learn D, I'm sure this wouldn't have been a big obstacle. There were plenty of resources explaining the difference and I'm sure there are more now. I'm just saying, anecdotally, that this was the roadblock for me.

Big nope. Biggest nope.

At the time I was super enthusiastic to try out (many years ago at this point), it wasn't open source so I decided to wait it out.

Later, I decided to try it out again, but I had to choose between Phobos and Tango. I didn't have time to evaluate them so I bought a book on Tango. I shelved it because it seemed like a lot of stuff was still changing.

When I tried again a couple of years later I wasn't sure whether to use DMD, GDC, or LDC. I didn't have the time to evaluate the compiler implementations, I just wanted to poke at it and try it out, and wanted to look at a bunch of examples before I jumped in. Three compilers made it a pain in the butt so I put it on the backburner and forgot to ever come back.

At this point D had asked too much of me to figure out how I wanted to use it, three times over, and I wasn't about to commit myself to researching the implementations instead of just hacking so I abandoned D despite initially falling in love with it. By that point, other good native C++ alternatives had matured - Go, Rust, and Swift – for different use cases.

After giving it three shots to give me a simple and consistent development experience I'll probably never try D again.

Meanwhile, Rust has one compiler and I have multiple choices of IDEs which all support the toolchain - I just set it and go and it tends to do just what I want because all that common surface area in the Rust community gets improved for everyone.

D is a great language hampered by a depressingly frustrating developer experience, and as such until that changes it is deeply hurting its own competitiveness with everyone who isn't committed to using it and making it work for them right off the bat (many many people).

I also know one FAANG company that invested in D is seeing a very noticeable shift towards Rust instead.

In my experience, gdc has produced faster code than ldc for my problems. This is subjective, so please don't ask me to produce benchmarks. I just remember gdc outperformed ldc in some cases, that's all.

GCD is the greatest common divisor, and D is the language with the greatest common set of features relative to the set of languages that the gcc suite can compile. So in many ways it is an equivalent to the GCD.

Not all standard GCC frontends are written in C++, e.g. GNAT.

Uhh no, not really, GNU doesn't "require C or C++". First of all GNU coding standard says C is the most recommended language, not C or C++. It even suggests Java before C++ (but I suspect that's a relic of old GNU AoT Java compiler?) and requests people not to use templates (which is hardly what we call C++ nowadays). Other than that, it's 100% ok to write a GNU package in any language people can generally understand and there is a free implementation available, like python, lisp etc. Scheme (via GNU Guile) is even the "official extension language" of GNU and emacs (one of the more popular and older GNU packages) is mostly written in lisp.

You must also understand that GNU optimizes for masses to understand the source code, and GNU coding standard was written when C was a very popular language and investing in any other language would just be a gamble. Imagine GNU being written in TCL or Ada... C was and still is a safe choice if you want a good deal of people to understand your code decades later.

Native English speaker: https://en.wikipedia.org/wiki/Walter_Bright

I think some of the third option, and also it’s fun to go to the trouble of digging out a lesser known word from the depths of your dictionary/brain to show just how much you appreciate something.

I'm guessing the first. I'm a native speaker and I know this word. I don't use it in speaking (it's a bit if a mouthful), but I use it occasionally in writing.

I think it has better imagery. When I hear "tireless", I think of being tired, but forcing myself to stay awake. When I hear "indefatigable", I think of someone playing sports or going on a long journey and pushing through the physical exhaustion.

So yeah, a bit of the first and a bit of the third most likely. Walter Bright is the author of the D language, so I expect him to be intimately aware of the effort required, hence the more vivid imagery.

It's an odd word, isn't it? I can't speak for the inimitable Walter Bright, but I suspect many English speakers like myself enjoy the pure sound of it - so many consonants in such a short space of time. Somewhat difficult to pronounce, slightly archaic, it perhaps confers a little more kudos than commoner alternatives. (And thoroughly deserved kudos, in this case!)

Any fan of Monty Python and the Holy Grail would be familiar with the term:

https://youtu.be/m9wdYy3tCm4?t=62

The GURPS role playing system uses the term indefatigable as part of its game mechanics. Additionally, the Film Reroll Podcast uses GURPS as their game system. My guess is that OP either has played GURPS or listened to the Film Reroll.

Also OP could just be really well read.

Personally, I'm glad to see indefatigable in the wild (at least more in the wild than a game system and a pod cast). I think the word is really cool and I haven't found an opportunity to use it myself.

It means persistent, tireless. It saves space and conveys more meaning than just tireless.

I like it. I think it's a well-chosen word.

As another data point, I'm a native English speaker, and I hadn't heard the word before, but I was able to figure out the meaning (which I confirmed by googling it)

I was born in America :-)

I don't recall ever hearing the word, but it appears a lot in books I've read, even recently written ones.

"indefatigable" fits what I wanted to convey better than "tirelessly". From the Cambridge English Dictionary:

"always determined and energetic in trying to achieve something and never willing to admit defeat"

Iain has had a plethora of reasons to abandon the project, and nobody would have blamed him. But he's persisted in the face of little encouragement, less support, and lots of complaining. It's a massive achievement. Indefatigable is the perfect word.

I appreciate it when you folks do this. But the UX for the reader isn't great, in that I must separately open your link to see the contextual parent of the split thread.

Perhaps you can prefix the split post's content at the same indentation level as its own content with something like Moderator-edit: Split from $URL as offtopic, original parent was: $PARENT or somesuch would help.

I think you detached it backwards? Surely the part you linked to should be in the main thread (The D Language Front-End Merged Into GCC 9), while the discussion of "indefatigable" should be split off into another thread?