I've never tested my hand with Rust, but I've come to appreciate reading its ecosystem of champions who seem to be, like this is hard. that's a good thing.
...except when it comes to build and packaging problems.
The thing missing from this conversation is that we're talking about Rust the language, C the language, and C++ the language. In practical terms, the ways you go from "this is source code" to a running program matters a lot for end users.
Point being, so far the Rust community mostly camps out in cargo land and ignores the hard problems of how to get systems code into the various ecosystems that benefit from close-to-the-metal programming. Maybe some day it will be figured out, but it's essential complexity to the broad problem space.
That is, admittedly, something Rust has not prioritized. I think it was probably the right decision given how successful the cargo approach has been in terms of bootstrapping a language community.
There are some very talented people thinking about the interoperability story, but it is also hard so they haven't committed to a solution prematurely.
In theory. In practice, there are a lot of complications to sort out, especially if you want to have Rust call C that calls Rust that calls C that calls C++. Build requirements of transitive dependencies need to be communicated and propagated, keeping in mind that C and C++ rarely uses cargo and at least public Rust crates rarely use anything else.
I wish that were true. If you dare mention finding anything hard in Rust circles, you'll get swamped with "no, you're wrong, it's dead easy!" responses (with the obvious implication about anyone who finds it hard).
More specific questions will often get extremely helpful and detailed responses, so I'm not remotely claiming the community is horrible. You just have to project a fair bit of "Shiny Happy Rust Person" to get on with it if you don't want to get bogged down with pimply arguments.
I suspect there are two factors at play: first, there are a lot of drive-by rust critics who spout of stuff they've read that plainly haven't really tried using rust themselves; second, I suspect that people want others to understand that while it might be challenging, it's not as hard as most people make it out to be and the payoff can be worth it. While you might find forward progress hard initially, you won't accidentally delete the universe in the process, and the compiler and rust community is quite helpful in getting you on course.
For me as someone who came from primarily working in Python, I really appreciate the strict type system that comes with Rust and have been quite productive in it, even if it feels like I've hit a wall at times. I think it'd be a shame for other people in my shoes to not even explore the possibility because they think it's only meant for a certain class of low-level C++-style programmer.
> there are a lot of drive-by rust critics who spout of stuff they've read that plainly haven't really tried using rust themselves;
I haven't come across this so much. More the kind of YA male philosophy undergrad types (of all ages & genders) which tech in general and Rust in particular seems to attract. These people just like to argue. A lot. In interminable screeds, often on the Rust user forum.
The attitude is certainly more loud than universal. Many of the most thoughtful (and helpful) Rust insiders recognise the language's difficulty. The Rust Foundation certainly does, to the point that making Rust more tractable to learners is one of its current stated goals.
> I think it'd be a shame for other people in my shoes to not even explore the possibility
Rust's current cultural kudos in dev circles is such that I don't believe this is really a factor. Many want to try it. It's more that Rust is just difficult for many to actually work with. I don't mean 'learn' in the absolute beginner sense. There's no shortage of excellent and generously accessible materials (the Rust Book amongst others). They're not that difficult to get through. But many find that once they've got a minor grasp on the whole language, it's just a real slog to get anything substantial done with it. Getting through all the Rustlings doesn't mean you can get anywhere near writing real software at a motivating pace. This is certainly my experience, and that of all the pro devs I personally know who have started to learn Rust, all of whom (other than me) have dropped out in frustration. All of whom (including me) have by the way learned and used many other languages without the same troubles.
Pretending (or passively-aggressively asserting in response, as so many do) that Rust is easy does nothing other than (truthfully or not) trumpet the abilities of the arguer.
My guess is there are many factors at play. Some of it may be attachment on the part of those who have clearly exerted great efforts to learn Rust, and perceive assertions that Rust is difficult to be negative criticism (often wrongly). Partly it's the argumentative immature adults that tech fields so often attract. We all know them. It's my guess that Rust, being more towards the techy end of that spectrum, does so particularly (I don't know if this is equally true for C/C++). Partly it might be Rust's self-conscious inclusiveness: a positive in itself, like many similar ideals it can lead to aggressive denial when more clung to as an identity than pursued on as an aspiration.
There you go. My interminable screed. Maybe I would fit into the Rust 'community' after all.
> It's more that Rust is just difficult for many to actually work with. I don't mean 'learn' in the absolute beginner sense. There's no shortage of excellent and generously accessible materials (the Rust Book amongst others). They're not that difficult to get through.
This is something that I noted when I first picked up the language: The rationale and explanations made sense, I could "learn" the rules, but in practice it was much harder, because I hadn't internalized the rules, nor fully grasped the consequences of those rules.
Having said that, I wish someone had told me ".clone() early, .clone() often" and "only return borrows if they are borrowing from an argument, otherwise use owned values" for the first 3 to 6 months. Having to learn the intricacies of borrowed values and a whole FP-inspired systems language at the same time is a lot.
Another rule of thumb I always try to emphasize for beginners:
Don't add lifetime parameters to your structs. Sometimes the compiler will suggest that you do it, but ignore those suggestions. Concretely, always make your structs hold String or Vec instead of slices. In 3-6 months you can ignore this rule.
I hear this a lot. But don't see that much evidence. Is it hard? Yes. Is it impossible? I came to Rust from Java and despite hurdles I learned it during it's most difficult part - before lifetime elision.
It's not satire. It's not happy shiny Rust is perfect nor demonstration of it being easy. Despite what you want it to be.
I'm around average developer of 40ish years, that learned Rust when it was at its hardest.
And yes, going from Java to Rust was hard compared to C#. I needed months to get proficient, compared to mere hours in C#.
Honestly, learning Git was harder than Rust. That took 4-5 months to re-learn it proper and get rid of training wheels.
And it was as hard as learning Haskell/Prolog. Hell, I'm still horrible in Prolog. And people don't complain as much about those two.
People seem to forget that saying "A new programming language should completely change your mental model", otherwise you're learning a new dialect not a language.
> And people don't complain as much about those two
Why do you opt to label plain descriptions of Rust as being difficult as 'complaint'? There's nothing inherently wrong with something being difficult to learn. Au contraire, I would have thought, unless the difficulty is unnecessary, which isn't something I've seen levelled much against Rust. The Rust Foundation has 'Flattening the learning curve' [sic] on its 2024 roadmap: https://blog.rust-lang.org/inside-rust/2022/04/04/lang-roadm.... Is that a 'complaint', or just a reasonable response to an empirical reality?
The complaint, inasmuch as there is one, is against the loud subsection of the Rust community which swamps any reference to Rust's difficulty with "no it's dead easy! You're just wrong!" (they leave the 'and probably thick' as an obvious inference, stiffly maintaining the rictus).
It’s not that hard in the end, just up front. It has a learning cliff with a plateau at the top. When you get it you are like “wow so this is how you make all those threading and memory bugs go away forever with near zero overhead” and you are good to go.
You never go back. It’s nice writing code that just will not fail in certain ways.
