> Here, it is clear that Rust is held back by its commitment to not break existing code (enacted by the edition mechanism), while C++ is free to implement backwards compatibility breaking changes in each new version.
I'll explain the joke, as it's subtle. Rust indeed has an explicitly stated backwards compatibility guarantee, which limits evolution of the language. One example of that is Range not being Copy because of some decisions taken early on; most people would agree that this was a mistake. There is an "edition" mechanism that allows some evolution, for example adding new keywords, but it can't solve everything.
C++, by contrast, has a tradition of maintaining backwards compatibility, but it is not enforced systematically, and in practice migrating to newer versions of C++ can be a painful process. Thus, in many application domains (especially embedded), developers are stuck on very old versions of the language. There's also a very sticky issue of whether binary (ABI) compatibility is guaranteed. There's nothing in the standards process that guarantees this, but there has been huge resistance to proposed improvements that break ABI. This was a particular sticking point for Google[1], as it affects unique_ptr, making it not so much the zero cost abstraction as originally hoped.
Language evolution is a difficult problem, and there is no magic, obviously correct answer to it. But I think Rust has a good, pragmatic approach, and the flaws such as Range are a very small part of the overall language surface area.
Modules are a particularly disruptive to the ecosystem. It's taking a long time to get them properly implemented in C++, and it also requires fairly major changes to code bases, build systems, and other infrastructure to migrate to them. By contrast, Rust has had a decent module system since 1.0 (with various tweaks and changes through the edition mechanism).
Edit: and as 'wongarsu says in a sibling comment, another part of the joke is that Rust doesn't need as much evolution as C++, as it already has a lot of the advantages such as a working module system.
That's partially the joke. The other part is in the preceding sentences:
> C++20 brings us modules, an innovative new feature, and one I’m looking forward to actually being implemented fairly soon. Looking forward, C++26 will likely have stackful coroutines, the ability to embed binary file contents to initialize arrays, a safe range-based for loop, and many other goodies.
> By comparison, the pace of innovation in Rust has become more sedate.
The reason C++ is getting all these new features while Rust isn't is not Rust being held back by backwards compatibility, but that Rust has all those features already.
So he's basically saying: C++ is breaking backwards comparability to (eventually, years after the spec was published) bring us features that Rust already has.
The joke is that Rust used to be the one making breaking changes (a while ago), and now they have an explicit "no breaking changes" promise. C++ had a strong tradition of no breaking changes, but the C++ committee is now trying to make a shit load of them.
There is no backwards compatibility with popular programming languages. Syntax, dependencies, documentation etc changes so fast, that when I tried to get some simple example working, there were not any working examples at:
1) Official documentation
2) Official source code
3) Google search
4) ChatGPT4
So I feel, that to get anything done, I need to find those programming languages where syntax did not change, and that have existing documentation and books, with examples that still work, and where reading syntax does not require mind bending to impossible shapes.
I did not read that article as being a joke. It got me more interested about C++, that is refreshing.
None of the examples in the official documentation complied?
That's probably an issue with the setup instructions. You probably don't have it installed right, or ran the compiler wrong, or something like that. Many languages are bad at explaining this part.
Unless this was a tiny hobby language the docs should compile.
My personal take on why it's funny is exactly that: it's technically arguably true, but in practice it's nearly the exact opposite of reality. It's basically a perfect troll in that sense.
This is well done.