As an example of where it is a problem: anyone attempting to learn Rust runs into a huge amount of example/tutorial code that isn't all that old but will fail to compile on the latest rustc. It makes for a really difficult learning experience.
What the comment said was:
> can't compile something written by a rust dev today with a rustc compiler from 3 months ago
This is taking new code and using it with an old compiler. Because of how deadly seriously rust takes backward compatibility, it tends to not be an issue. Just get the newer compiler to build the newer code.
This also isn't a unique problem to rust. You can't use features in any language with compilers from before they were introduced. Funny enough, even with rust's rapid growth, I actually have less issues with it in rust because of the ease of upgrading.
I think part of the problem is that this is backwards to how people coming from other traditional languages (like C, or C++) think.
With those, you deliberately choose your target compiler in a way to maximise who can build your software. Telling all your users "just get the newer compiler" is rude. If you can reasonably target a 20-year old version of the compiler, so that users on systems who can't upgrade their compiler for reasons you have no control over can still build and use your software, then that's a trade-off worth considering.
Note that you don't always have to choose that, but you should consider it. And when you do decide to move from, say, C89 to C99 (or - gasp - C11), that is a carefully considered decision. It's not just ooh, shiny.
You don't always know who all your users are, or why they may not have the same flexibility as you. But if you want your software to be installed on 10 billion devices, that's the sort of thing you have to consider.
https://daniel.haxx.se/blog/2022/11/17/considering-c99-for-c...
> Telling all your users "just get the newer compiler" is rude.
With Rust you don't have the same things holding you back. Features and targets are extremely well supported and for a long time. This compatibility is a die hard sacred tenant. This a good thing! It should be celebrated and shouted from every roof top! It isn't rude that the level of engineering allows this to be a low drama affair. Without the use of RUSTC_BOOTSTRAP it is very rare to have something holding you back on an older, stable compiler. I can think of one major bump of supported OSes a while back and that's it.
You can stay on older versions of the compiler if you really want to, but don't expect to be able to build new code that uses new features.
[citation needed]
Rust has maintained backward compatibility to a level even beyond what golang has done. Code written for Rust 1.0 will compile on latest Rust, minus a very scant few edge cases where it should never have compiled in the first place except for a compiler bug.