meh, rust is still better cos it’s friendlier
I have my gripes with rust, more it’s ecosystem and community that the core language though. I won’t ever say it’s a worse language than C++.
I like the Rust language quite a bit. I find the Rust community to be one of the most toxic places in the entire tech business. Your mileage may vary and that's fine of course - but plenty of people want to stay far away from a community that acts like the Rust community does.
On the surface it sounds like a community with such deep pathology that it will take at least a generation following a complete change of leadership to have a chance at recovery. But there are three sides to every story.
> On the surface it sounds like a community with such deep pathology
First what sort of pathology? You're confusing community with leadership.
The community didn't want this, and leadership was doing a restructuring due to change from Foundation and Project. Welcome to OSS projects.
Second as opposed to what?
A community at the beck and call of your CEO dictator? I'm a Java dev, so all it takes for Java to die is for One Rich Asshole Called Larry Ellison to decide that they (ORACLE) are inserting two mandatory ads to be watched during each Java compiler run. Or god forbid that they will monetize Java.
Plus if I had 24/7 insight into how Oracle worked, I'd probably also be much less inclined to join Java as a new dev.
To paraphrase Tolstoy: (All perfect languages are dead;) Each imperfect language is imperfect in its own way.
I can try to answer your questions if they are important to you, but it will require some significant effort, so I'd like to be sure they aren't rhetorical first.
And how does it differ from the average Open-Source Project?
For example, in your example of "inserting two mandatory ads to be watched during each Java compiler run", the OpenJDK license guarantees your right to remove those ads from your copy of javac, and to redistribute that copy of javac as the official Debian or Ubuntu version of javac. F-Droid does this routinely to such "antifeatures" in open-source Android applications, and of course Android itself exists because the open-source licenses of projects like Harmony, IDEA, and Eclipse protect Google from such malfeasance.
I'm not sure what the "average open-source project" is. Maybe something like https://github.com/justinasr/FantilatorOS/, the firmware for a redundant array of 64 inexpensive muffin fans that someone set up at CERN? https://web.archive.org/web/20231010215437/https://onlyfans.... Or https://github.com/antimatter15/splat, a Gaussian splat renderer in WebGL? I think those are both "non-average" in that they have a very above-average number of forks and stars. But, like the overwhelming majority of open-source projects, neither of them has a community in any meaningful sense, so I think the question doesn't make sense, given that it's a question about community dynamics.
It wasn't a serious example. But if tomorrow Oracle decided to monetize Java (which they have for LTS) there is little you could do.
> I'm not sure what the "average open-source project" is.
Look at Github. Take several random non-fork repos. It's most likely a lib written and maintained by 1-3 people, where last update was 4 years ago.
Maybe that’s more of a bias with rust media stuff, seems to be going deeper into that rabbit hole though.
The community was at least, may still be, very sensitive to rust being criticised. I genuinely brought an example of a provably correct piece of code that the borrow checker wouldn’t accept, interior mutability problem. I was I should build a massive abstraction to avoid the problem and that I’m holding it wrong… Put me off the language for a few years, it shouldn’t have, I should have just ignored the people and continued on but we all get older and learn things.
My favorite is when Rust gets dragged into weird American "culture wars" - somehow, it's a "woke" language? (And somehow, that's a problem?)
But yeah, the language docs are pretty up front about the fact that the borrow checker sometimes rejects code that is provably fine, so it's a weird criticism. The nontrivial breakthrough was that Rust proved that a huge amount of nontrivial code can be written within the restrictions of the borrow checker, eliminating swaths of risk factors without a resource penalty.