The changes:

* .await. This feature was in development for almost five years. Landed November 2019. This is a legit new feature, with significant ramifications on the language.

* try!() -> ? . This feature was in development for two years, and landed in November 2016. This largely consists of the transformation "try!(x)" to "x?".

* impl trait: this feature was in development for two years, and landed in May of 2018. This has two major parts: one that is very rarely used that is mostly sugar, and another that's pretty useful, and is a legit new feature.

* dyn: this feature was in development for two years, and landed in June of 2018. This is largely optionally adding `dyn` in some places. You don't have to do this. You can turn a lint on that will tell you exactly where to do this, and it can be automatically added to your code.

So that's four features. One of them three years ago, two two years ago, and one last year.

That's awful hard. People have to learn an entire new feature each year? :D

I don't get why people complain. C# is pumping features at a much higher rate and most people are glad. Those features do solve some issues or make it easier to solve them. If you don't have an use case for them, then you don't need to learn them.

Sure, but if you list out C++'s warts, you'll find a much longer list spread out over 30 years. The same effect holds, no?

Not necessarily. The way that new features fit together with existing features has a big impact on how useful and beneficial adding those features are.

In C++, using modern style is .a nicer experience, but at the cost of having to stay away from any code pre-C++11. This is not because C++ designers are bad, but rather because they have more cruft due to existing for longer. Time will tell if Rust will go down that same road, but right now new features fit with the rest of the language and are usually extensions to things that already exist but that weren't allowed in places.

But... again... the contention of the linked article, and one I share, is that these new features don't "fit with the rest of the language" and keeping up with them represents needless cognitive churn.

I mean, sure, that's an opinion thing, and obviously you don't share it. But to me, watching from outside the core rust community, it sure seems like exactly the same thing that happened to C++.

It really, really, really needs to be stated that the thing that triggered this whole discussion is not a "new feature", it is not even an RFC, it is a blog post written by a prolific Rust developer who also turned the idea into a library, and wanted to share the merits of the idea.

The fact that it's controversial and "doesn't fit with the rest of the language" means it will very likely never become an RFC in its current state, much less become part of the language.

There is no need for the author to make constant changes to his code. It will continue compiling just fine. Moreover, new "editions" come along with nice documentation on what changed and tooling to automatically fixup code, and are totally opt-in. You can simply wait for a new edition to come along to update your code -- or not, it doesn't ultimately matter that much.

I mostly wrote C++98, or at least, C++ of that vintage, so I can't really speak to how hard it is to keep up with later C++ standards. Just providing more context for those specific list of changes, and their frequency.