Interesting. I witnessed a constructive collaboration by which the Rust community chose (mainly) the syntax for it's async features. I thought of it as amazing, thoughtful, rather democratic and on point. Nothing war-like to me.
That’s your subjective point of view, not everyone agrees with it. Part of the problem is that Rust team failed to find a solution good enough for the most people and failed to communicate this decision. In particular the switch to .await syntax happened just couple weeks before it was finally stabilized.
And await is not the only controversial decision made by the Rust team.
Even if 10% of people unhappy that’s too much, because the next controversial feature will cause 10% more of unhappy people and so on.
I hope they will do better next time.
You realize this is an impossible standard, right? Literally impossible.
Same for Java, IIRC the only controversial decision they made was the introduction of modules.
Python 3 was a mistake, but generally Python users are happy with Python changes.
10% is not impossible. Even if this decision is ”right”, communication could be better: more options to play with different syntaxes, more time to get used to new syntax before stabilizing are just two possible ways to deal with the angry mob.
I believe you are mistaken. C++ community has a lot of diverse opinions about its features. As an old saying goes, it is possible to use only the good subset of C++ features, the problem is every shop has its own subset. Even about something as basic as exceptions there is no consensus. Similarly, not everybody is happy about the "modern C++" movement. I guess these people are just confident that thanks to serious commitment to backwards compatibility they will be able to continue writing code in their old grumpy ways so there is no need to loudly express their dissatisfaction.
Rust community is much less fractured (in part because it is smaller and younger) and there is a sense that decisions made today will determine how everybody will write Rust code tomorrow. Combine that with efforts to encourage an inclusive discussion and you get a lot of disagreement visible in discussions, especially concerning aspects that are prone to bikeshedding.
Coroutines were quite co_ntentious.
Maybe the difference is that very few C++ developers live on the bleeding edge. I don't use anything unless it's available from the default packages on an LTS release. So, I won't be using C++17 until I update to Ubuntu 20.04 later this year. And compared to the older developers in my lab, I'm an early adopter.
By the time new features reach the average C++ programmer, they're just how things are. The pain and the fighting of the standardization process is just distant memory that happened to somebody else.
If anything if 10% of C++ users are happy with the new features in a release it's a great success. I see a lot of complaining about the committee, its decisions, and its decision-making process.
The syntax was introduced in May, while the feature was stabilized in November.
As for your second sentence, RFCs are almost always accepted before they are implemented. There is an entirely separate round of review and approval before an accepted RFC can become a stable feature of the language.
That's fine when * RFCs are not controversial * RFCs does not change much before stabilisation
> The syntax had been proposed long before then
Let me rephrase it this way. It was only a couple of weeks when syntax became available in nightly before the final decision was made.
And while the syntax discussion saw a ton of comments, the more important underlying semantic aspects of async/await got a lot less attention - even though they also had and still have a few issues to resolve (e.g. around cancellation, thread safety, extensibility).
Here are the results of a survey ran on this syntax on about 400 Rust users from rust subreddit : https://i.redd.it/660zjw4rhsv21.png
You'd see the chosen syntax (field-like access) was one of the most disliked one…
Syntax is something very emotional and beauty is very subjective. Thanks to the Rust team, the discussion around await syntax was mostly focussed on rational arguments, not around perceived beauty. The outcome is great in my opinion.
I also guess that, since part of the implementation was sponsored not by mozilla itself, then also the syntax choice was not led by mozilla itself (nor the overall community).
I could be wrong - and I only superficially followed the discussions - but this is the impression that is left on me after all that.
edit: but I think that this Ok-wrapping feature is different from the await one, since now there are no more deadline-like pressuring into mozilla/lang team. So I guess that now, something that is generally disliked (if it is) won't actually get into the lang..
This is not true. Several people on the lang team (and many community folks) changed their positions several times over the course of the debate.