[hansvm]

Rust was ~70% of my last job, and the other Rust engineers there were very competent -- large volumes of high-quality, high-impact code. In my rust community interactions at the time, also interactions with my colleagues, I definitely noticed some unsavory trends. An example pattern is:

me> This [API | language feature | whatever] seems harder to use than it should be.

them> No, it's actually not.

me> Here's irrefutable proof.

them> Well at least you have memory safety.

me> But...you can have memory safety without this thing being a dumpster fire. Wouldn't that be better?

them> <no concessions, Rust is perfect>

After a few conversations like that, I've literally had those same otherwise high-caliber engineers spend days wrestling with the "easy" thing we were quibbling about. I'm sure it's not intentional, but it comes across as religious gaslighting.

And maybe I just interacted with the wrong people at the wrong point in Rust's lifecycle and the community is mostly very positive. I see enough people with experiences like mine though that I'm not willing to believe it's a truly miniscule fraction of the language's discourse.

[torginus]

Its academia. Rust is admirable for having been able interesting programming language research into a mainstream language, but this had the implication of bringing the people who did said research with it into the communities.

It used to be that programming languages were mostly boring and predictable, with maybe questionable semantics (const etc.), but generally that messiness meant they were good enough at getting the job done.

PL research and theory focused on mostly FP, Ocaml family and other functional languages, with things like advanced type inference system, based on postgraduate category theory. These people have fought endless and bitter mental battles with each other, a glimpse of which occasionally leaked to HN. Some paper about a noteworthy discovery in solving a problem incomprehensible to the general public. Some guy complaining about how he tried to educate average programmers about how unsound their programs were, and being taken aback at how these people didn't want to be saved from their own stupidity. Some article complaining about how if every programmer was just 15 IQ points smarter, they'd be all doing FP. But mostly this community kept to themselves.

Thanks to Rust, all these ideas have found purchase in real practical software. Now the academics get to torment themselves with the moral duty of saving the everyman from using less theoretically sound programming languages.

(Disclaimer - I don't hate Rust, I think it's great they made this breakthrough from academia to regular boring programming, but they need to respect the nuance of the world that exists outside the walls of research institutions)

[asa400]

I've been using Rust in anger since ~2018 and I guess I've had completely different experience, especially compared to what I was mostly doing before, which was Scala.

Scala (the v2 series, I haven't used v3 at all) was, to a first approximation, a language of, by, and for graduate students in language research that accidentally escaped the lab and briefly took over the data engineering space. Multiple competing category theory libraries, vicious fights about which was more pure, continued debates about the beauty and confusion of implicits resolution, the list goes on.

Rust seems downright blue collar in comparison. So much of the Rust I've written and the teams I've been on, and the open source we've used has been exactly the kind of stuff we would have used Java for 15 years ago. Boring practical stuff. Same goes for the community interactions. "Here's how to get this thing working", "here's a better way to do this", "maybe you didn't know but here's a cool way to speed up that section", etc.

Sure, if you go into the development process of The Rust Language Itself, people are talking about compiler minutiae and using datalog to do type resolution, but that _really_ has not been my experience as a user. Me and everyone I know use Rust like the Golang people say they use Golang.

In fact the crux of the difference between the Rust community and the Scala community has been Rust's continued obsession with developer experience/user experience (whatever you want to call it). The error messages, the tooling, etc. Scala had none of this. A disproportionately significant section of the Scala people were obsessed with type theory, quite often to the detriment of usability/programming experience.

I respect your experience with the Rust community but I haven't had this experience at all. Totally unrecognizable to me.

[pjmlp]

Rust is becoming the chosen language for those that would have previously used Haskell, OCaml, Scala, but now get to use something with more mainstream mindshare.

It isn't very hard to find folks misusing unsafe to mean something else other than memory safety, or their own ZIO like frameworks.

[asa400]

Not sure I understand the point you're trying to make. Can you rephrase?

[pjmlp]

Easy, some folks write Haskell or Scala in Rust, because it allows them to reach a wider mindshare.

So they write their monadic and effects frameworks in Rust instead, and use unsafe to mark methods that might be dangerous, regardless of related to possible memory corruption or not.

[asa400]

Any examples? I haven't seen this personally.

[brabel]

Rust didn’t start in academia! It was a practitioner’s pet language until Mozilla started sponsoring its development. It’s actually the exact opposite of an academic language like OCaml and Scala, which were started by researchers in universities. Rust did incorporate some academic ideas like the borrow checker and algebraic data types, but the former was already being used in a precursor language, and the latter was almost becoming mainstream (which it is now, Rust helped a lot with that but was one of several languages that had it).