I remember hearing about D fairly early on and thought it sounded interesting, but there wasn’t a compiler for the kind of targets that I was working on. And then every time I’ve heard about it since it’s been that there was some interesting things being developed for it, but that some inscrutable community drama meant that it once again was floundering. ciiiiiircle of life
D is more than 20 years old (from 2001), so it’s due for a renaissance, Python was also in its 20s before it became fashionable.
It kind of bounces back after the catastrophe that D1 vs D2 and Phobos vs Tango caused, but might be broken by AI bros trying to chase the vibe coding trend.
Don’t get me started on D2. I mean, having an underfunded pee-wee hockey team represent the country in an international tournament after one good season? Seriously?
Many years ago I read the D book and really liked many aspects of the language. What kept me from using it was the ecosystem. They had three compilers and two different standard libraries, none of which were fully compatible with each other which led to a whole bunch of weird problems. These days it’s probably better. Maybe I should give it another chance.
If nothing else, there’s also OpenD, which might be better for you based on your requirements.
3 Ds? That’s too many! Let’s make a new D that encompasses them all!
/j
There’s now 4 competing standards.
TBH, the compiler issue mostly resolved, only thing that is still problematic is module constructor order between DMD and LDC.
Was there drama with D? I’m out of the loop…
Multiple in fact. D1 vs D2, Tango vs Phobos, mutable by default vs const by default (was minor, but allegedly lead to the existence of Rust), Adam D Ruppe leaving and forking the compiler (OpenD - might be useful to you depending on things), “let nazis code” (though DLF have not only backtracked on it but also set up some basic safety measures), etc. Can still recommend the language if you want a more C-style language and not OCaml with curly brackets, or if borrow checker is a dealbreaker for you in Rust.
“let nazis code”
What do you mean by that?
(Also, if possible, please do more of this meme with other languages)
We really all need to get along and accept each others’ opinions. Even if some people are completely wrong and think mutable by default it OK. Hehe.
The Wikipedia article for D links to this blog post which seems pretty damning.
I think it’s just a joke about slang aka D for Dick.
This is definitely about the D language, I just haven’t heard anything about in a long time (since Rust ate its lunch) and nothing about it using AI or long time devs leaving.
There have been something where some developers left, but I don’t remember it well enough to search for.
Sounds like a GAME-CHANGER!
Did they ever sort out the GC vs nonGC standard library kerfuffle? I was interested in dlang quite awhile ago but the ecosystem seemed fractured (and not big enough for that to be ok)
Yes, they’re letting the community to deal with the noGC part, while Phobos will be strictly GC in the future.
/c/unexpectedmetallica
It really does mystify me what anyone thinks they’re accomplishing by creating a brand new programming language these days. Other than a purely academic exercise, of course.
Whatever features you want your language to have, there’s probably already a language out there that’s damn close to it. And if your ideal language is just like some existing language except for a few niggling details … then there’s no need to start from scratch – just make a modified version of that language with a few little changes to make it act the way you want.
Programming languages are just about a solved problem now, IMO. I can’t imagine any scenario where creating a new language from scratch would be better than tweaking an existing language … or just using an existing language as-is.
I think there are programming paradigms that haven’t even been discovered yet. Rock music was “discovered” centuries after baroque music, and composers back then would have thought baroque music is the ultimate musical genre, which could not have been improved upon.
I’ve been working on a programming language recently that sort of programs itself. It’s hard to explain how it works, since I approached it from a mathematical direction, but for a domain and range defined with a set of correct input-output pairs, there are an infinite number of functions which correctly maps one input to its corresponding output. If we define f_1 as all functions which correctly map the first IO pair, f_2 as functions which correctly map the second IO pair… Etc etc until we reach f_N, then the set intersection of all f_1…f_N is the set off all functions which satisfy our requirements. From this set of known correct functions, we can sort them by speed or some other trait.
But the devil’s in the details there. I won’t go into how I get f_1…f_N, but I’m having fun thinking about it & designing it. It may even be useful some day.
Rust is pretty fresh and really innovated a lot with its actual safe-by-default approach in a non-managed language actually able to replace C and C++.
Most new languages aren’t a Rust, but just a Python (yet another low-performance language assuming you don’t actually need strong typing to realize later that actually, you do). But a Python is definitely easier to get started with than a Rust (or the footgun languages, it is able to replace). So there is definitely a use case for that too.
Go is a good case of a young system application language designed for simplicity.
And everyone creates a domain specific language once in a while. Those can make specific tasks a lot easier.Programming languages don’t really look like they are a solved problem. It seems like everything gravitates to Hindley Milner over time. But mainstream languages finally adopting null-checking at compile time by default and language features for parallel execution reaching the mainstream are recent enough that I think, there might still be a long way to go.
And obviously, you want AI to code in a language which is as much deterministically compile-time-checked as possible because of the hallucination problem (which btw, is also present in humans; the technical term there is brain fart). I expect that to be something which requires writing actual mathematical proofs like one does in Coq solely because AI doesn’t try to kill you if you insist on it writing mathematical proofs for everything.
The scaling limit already is the humans who have to do the code review. So any language which makes more bugs more obvious before the code reaches the review stage is extremely valuable even if writing code in it is a real PITA for humans (as long as they can read it, it’s fine).the technical term there is brain fart
Or neuroactive substance. Like, drugs. And ADHD meds. And drugs.
strong typing
Grrrrrrr. (this term is ambiguous but still very popular for some reason https://en.wikipedia.org/wiki/Type_safety#Strong_and_weak_typing)
There are other well defined ways to describe a type system, such as:
- Static vs dynamic
- Implicit vs manifest
e.g.
- Rust’s is mostly static and sometimes optionally implicit
- Haskell’s is static and optionally implicit
- Python’s, Lua’s, etc is dynamic and implicit
- C’s is static and manifest
If you read the literature, particularly “Types and Programming Language”, you’ll find that “dynamic typing” isn’t even considered typing. If you can have a type error at runtime you’ve defeated the reason to add a type system: to reduce runtime errors. The hope is that “well-typed programs don’t go wrong” tho there are some limits to what any type system can do (e.g. Rice’s Theorem).
That said. Static v. Dynamic is much more precise than Strong v. Weak and should be preferred.
Implicit v. Manifest is less useful just because it’s a broad spectrum, basically inculcating how much type inference is done and “how much” generally depends a lot the input program(s). Haskell does whole-program inference, tho GHC (the only Haskell compiler) has a number of syntactic forms that can’t be inferred. Scala only does local inference. C doesn’t infer types, though is gets close with how it treats functions with no-argument in the prototype and varargs stuff. C++ uses auto for some type inference, which is still somewhat manifest, but also mostly implicit.
I think weak typing is a good name for when there are invisible coercions, but that doesn’t actually have much to do with proper types.
Anyway, great comment, If more people would use static/dynamic and explicit/implicit instead of strong/weak, there’d be less miscommunication.
Practically, dynamic typing is quite different from no typing, such as with the B programming language, although I agree that it often defeats certain benefits of type systems.
All you’ve demonstrated with this comment is your lack of imagination.
I prefer fetlang
