How a community is able to diagnose its issues and shortcomings, work on them and plan for the future!

There is lot to learn from this post, i think it can be helpful and useful

https://degoes.net/articles/scala-resurrection

On Wednesday, 25 January 2023 at 14:57:01 UTC, ryuukk_ wrote:

Oh, I think this community has done a more than sufficient job of documenting the shortcomings, and probably even invented a few that aren't there. It always comes back to the same problem - a lack of labor.

On Wednesday, 25 January 2023 at 19:35:10 UTC, bachmeier wrote:

Lack of labor is a second-order symptom. First-order symptom is a lack of motivation. The cause is this:
D2 can’t be fully fixed because of backwards compatibility (important clients, big codebase).
D3 can’t be created because of D/D2/Tango/Phobos PTSD.
Stalemate.

On Wednesday, 25 January 2023 at 20:31:13 UTC, RTM wrote:

There is a ton of work that can be done. Everyone instantly jumps to language changes, which frankly are irrelevant in terms of D seeing wider adoption. The language is already good enough. Maybe not for every use case, but definitely good enough to see much heavier usage.

None of the things you've listed explains problems with the tooling, lack of blogging and YouTubing about D, lack of certain libraries, etc.

On Wednesday, 25 January 2023 at 23:45:58 UTC, bachmeier wrote:

There are some language features that should not be neglected, the ones that are considered obvious to have in most modern languages, to name just one: Tagged Union with Pattern matching

Having to still advocate for it in and still seeing this much resistance in 2023 is kinda sad, to be honest

On Thursday, 26 January 2023 at 03:09:47 UTC, ryuukk_ wrote:

I'm not sure what kind of resistance you are talking about, but it would be useful to have some reassurance that the existing language features (which are already "good enough" as stated by bachmeier) won't be broken.

There are some useful language features that are missing. For example, I want to be able to return multiple values from a function and assign them to multiple variables, which is a feature that is implemented by pretty much every other programming language (even C++17 in the form of "structured binding"). But if somebody says that we can have it in D only in a way that breaks the existing software, then this won't make me happy and you will see some "resistance".

Today D2 is useful for developing software. But it's like building a house on a sleeping volcano. Even if everything is relatively calm right now, nobody knows when it is going to erupt and cause massive damage to the existing ecosystem. Also here's a quote from the linked Scala post:

"As part of this transformation, Scala 3 needs to commit to backward
compatibility, like Java, Go, and all other commercial programming
languages. There can never again be a “Scala 3”-style boil-the-ocean,
greenfield language rewrite. It’s time for the language to stabilize,
and for the focus to shift to commercial interests, including bug fixes,
improved performance, enhanced tool support, and optimizing."

On Thursday, 26 January 2023 at 11:30:02 UTC, Siarhei Siamashka wrote:

"As part of this transformation, Scala 3 needs to commit to backward
compatibility, like Java, Go, and all other commercial programming
languages. There can never again be a “Scala 3”-style boil-the-ocean,
greenfield language rewrite. It’s time for the language to stabilize,
and for the focus to shift to commercial interests, including bug fixes,
improved performance, enhanced tool support, and optimizing."

As an employee at a commercial interest, I honestly disagree. D has too much stuff. It needs to slim things down and commit to a cohesive vision. If that means breaking our code, we'll deal.

I see it as less building a house on a volcano and more joining a colony set in a toxic waste dump. If the house is irradiated and the kitchen chairs are made out of asbestos, by golly we'll have to tear it down. So long as it improves the health of the whole, I'm all for it.

(Of course, it's a question of cost-benefit.)

On Wednesday, 25 January 2023 at 14:57:01 UTC, ryuukk_ wrote:

To me Scala is the perfect example of how you can run into self-induced mental overload caused by an overly complicated programming language that tries to do too many things till you in the end start to believe that a programming language is the essence of life.

D has a much better feature balance than Scala. Besides, Scala 3 is a good example of how a new language version can wrack the whole language.

On Thursday, 26 January 2023 at 11:30:02 UTC, Siarhei Siamashka wrote:

"As part of this transformation, Scala 3 needs to commit to backward
compatibility, like Java, Go, and all other commercial programming
languages. There can never again be a “Scala 3”-style boil-the-ocean,
greenfield language rewrite. It’s time for the language to stabilize,
and for the focus to shift to commercial interests, including bug fixes,
improved performance, enhanced tool support, and optimizing."

That's what I would like D to focus on. Stabilizing itself, enhancing its features and fixing bugs.

I have always thought that new features are too easily accepted into the language. We do not need more bureaucratic processes, but rather a measure that will segregate what is needed or fits the language and what does not, no matter how convenient that awesome feature might be. But I guess it has to do with the philosophy of D; although, what's the philosophy of D? Need to do some reading...

I have never written any compiler code, so I maybe biased since I do not know the state of D in that realm... But, what I would like to see is a gradual progression and improvement of D: D2.99 => D3.00

No jumping from D2 to D3 and breaking existing code. We do have a deprecating cycle/procedure, don't we? Let's gradually improve.

A few quotes:

The language should be as simple as possible, then you should be able to do complex things with it. - Eskil Steenberg.

Bottomless wonders spring from simple rules repeated without end. - Benoit Mandelbrot.
    C is a great example of this. So many complex and powerful systems created that still
    run the world today. If C could, D can too.

Valuation can change over time.
    I don't remember where it came from, but it reminds me, what we build should be robust
    and withstand time; just like C did it, but the D way.

Everything that works is pretty simple.

Confidence is competence - actually knowing what you're doing.
    I interpret this quote this way: D must become competent at a one or two things before
    people become confident in the language. I think D does great on the GC part.

To be the best is the lonely rocky road. You need to have the passion to be with it both for ups and downs. - Kunal Desai.
    Well, D is the best. So it's natural we struggle a little, but it gets better over
    time.

Don't style-drift. Pick what works for you and practice it perfect. Don't be temped to go elsewhere. - Jason Leavitt.
    We shouldn't be torn apart by the plethora of new features and techniques that are
    devised nowadays. D was innovating years ago, maybe it's time for D shift its focus on
    improving the ecosystem, whilst watching what happens on the other side of a river,
    and gradually adopt what works. Because:

Either way, those who try to follow the trends have on their hard drives dozens of scripts that they can't run anymore.

Thank you for your hard work, D dev team!