> Rust has only become more uniform and contains less special cases than just a couple of years ago.

How so? Aren't await and ? both new special cases?

They are new features, so in some sense, they're "special cases", but even then, okay, so that's adding two special cases. Rust is still removing special cases all the time.

Take the Rust 1.42 release, for example. Way back in Rust 1.31, we removed the need for you to write `extern crate`. But when you were writing a procedural macro, you still had to write "extern crate proc_macro;". With Rust 1.42, you no longer have to, and it just works, like everything else. This removed a special case.

Rust has been doing a lot of the "this was special cased to ship, now we are making it more general like we always planned" lately.

What the GP means there is that when the list of new "features" comes out with each Rust release, if we discard the features that are just new stdlib APIs (~75% of the total count for an average release), most of the remaining "features" are just tweaks to existing language features that remove edge cases, e.g. non-lexical lifetimes.

As for your second question, async/await is absolutely the biggest thing added since 1.0 (and is an outlier in new features in that regard); the ? operator is just an improved version of the try! macro that shipped with 1.0.

The way I see it NLL added a huge number of edge cases. Pre-NLL it was clear what kind of lifetimes were possible; now I have no clue what the different lifetimes are and every keyword interacts with lifetimes in a different way.

Pre-NLL made the language incredibly clunky to use, with a lot of code acrobatics required to do something you know should work logically according to ownership but the scope lifetime rules wouldn't allow.

I don't disagree. But IMO a lot of clarity and comprehensibility has been sacrificed in the current implementation. I'd rather have seen a style that de-emphasised control flow keywords and made it easier to use closures, or simply blocks, to express the behaviour that people wanted. I've yet to see a case where what was really needed was NLL rather than better support for lexical lifetimes.

I don’t know any other “systems” language whose language definition changes every six weeks. When you say Rust changes slowly, what are you comparing it to?

Frequency of change and rate of change are very different. C++ (now) changes at about the same rate but in larger, less frequenct increments.

Do you think C and C++ didn’t change in their first five years?