Continuation of `Having "blessed" 3rd party libraries may make D more popular` DIP thread

[GrimMaple]

On Thursday, 3 July 2025 at 02:21:46 UTC, WraithGlade wrote:
> I am very tired of drifting from programming language to 
> programming language over the years always trying to find a 
> reasonable balance of factors (both expressive and native-level 
> performance, etc... vs sometimes thinking I'll just disregard 
> that and focus on just expressiveness or just project 
> completion pragmatism) and D has looked for the past few months 
> like that language but I have become much less sure of that in 
> light of some of the things mentioned in the original thread.

This is how I initially ended up with D myself, trying to figure 
out a better way
to write software than C++. I've been using D for 5+ years now, 
and I'm still using
it (well, I rather switched to OpenD actually) for my game 
development. But when I needed
to make a small build system for building embedded C++ projects, 
I made it in C#. That
should tell you enough to understand my view on the future of D :)

> Even if the precipitous drop in contributions to D is isolated 
> to the Phobos standard library, there still seem to be reasons 
> to be wary. In particular, it still remains unclear whether the 
> language and library ecosystem is a stable base to build upon 
> for real software, which remains the central concern.

Having done that, I would tell you straight away: no. If you want 
to start building Real™
Software in D, you'll most likely end up absolutely __having__ to 
contribute to multiple
3rd party project, or building a significant part of low-level 
libraries yourself. For me,
it was adopting dlangui (I still keep maintenance of it, if you 
file a PR I'll be more than glad to accept it). It also 
inevitably forced me and Adam to create OpenD, because
upstream D had very little care to anything non-compiler related. 
You could see D as
a language primarily designed to make a D compiler.

> Credit where credit is due: doubtlessly D has had lots of 
> wonderful work put into it and is very worthy of admiration and 
> wider use. I want/wanted to believe in it and intended to build 
> out my own tools for both a game dev idea and an art software 
> tool idea in it (plus miscellaneous personal scripting and 
> utility use), and perhaps even a simple reusable open source 
> GUI engine or a community book eventually if all went 
> especially well, but I am not sure what to think anymore in 
> that regard.

That being said (and being _true_), D is rapidly falling behind 
in terms of available
tech. C++20 added modules, for example. Since a few releases 
back, C# is able to compile to __native code__. Yes, it can 
compile to native code, without tucking behind a .NET library or 
JIT. So if you want a natively-compiled language with GC (which 
is why I personally selected D), you can now use C#. The world 
has gone so mad that you can actually __link-in C libraries__ to 
your natively built C# application. So the available reasons to 
use D are shrinking, as well as D's developing momentum is 
shrinking too. Now, C# is still far behind on manual memory 
management, and there is no real way to have any true NOGC code, 
C#'s GC has been improved to a point where it's not a performance 
issue at all, especially if you allocate objects wisely.

> I have squandered practically the entire past decade just 
> running in circles switching between different programming 
> languages and reading countless programming language tutorials 
> and books and messing around in them in aimless ways and 
> basically hardly creating anything real or substantive. That's 
> not the life I wanted for myself, nor is it even a responsible 
> way of living for me at this point given how much time I've 
> lost doing that.

I don't think you should be going too hard on yourself for this. 
Yours truly done this too, and nowadays can use 5 or 6 
programming languages reasonably well. It accumulates general 
experience, general knowledge, and fixes your brain from thinking 
in one language's paradigm. Look at D or C++ users for example -- 
they keep on battling manual memory management, when 95% of the 
world runs GC. Isn't it just a sign of idiocy on their side? :)

After all, it doesn't matter what language you use to make your 
software, it's what software you end up making that matters.

> I don't know what to do honestly.

Start making software instead of choosing the Perfect Language. 
It doesn't exists (maybe it's C# actually)