I do a sort of language-per-year thing for my sins. My previous two were clojure then elixir, Then this year it's been Rust. I've found the Rust community by far the least pleasant to deal with. For the most part, it is fairly helpful (though no more than the others). But there is an implicit contract that to get help you must admit that Rust is the best thing ever, and that if you have any difficulties with it, you agree that it's because you're a bit thick or lazy. Stay within that lane, and smiles & help will abound.
I'm not quite sure why the Rust community is so dogmatic about the language's intrinsic excellence. I never found anything similar with the clojure or elixir communities (which each has its own distinctive style of response to beginner difficulties). My speculation is that Rust has such a strong inclusiveness mandate (which is a good thing in my view), that intrinsic difficulty is threatening to the group's identity. The impulse therefore is to deny the difficulty, from which it's a short step to pointing to the beginner as the source of the problem.
I don't know if this is related to your experience, but one thing I have noticed a lot is that new Rust programmers experience some friction point with the language and suggest some sort of change to address it. This sort of feedback almost always seems to be rejected by other Rust users.
I don't believe it's out of a sense that Rust is perfect as it is. There are loads of discussions about where it does a poor job and how it can be improved. The problem is that the feedback from these new users is usually poorly received because the person has an incomplete understanding of the language. They may not understand that there is another, easier and more idiomatic approach to whatever problem they experienced, or they might not understand the values that underpin the language (Bryan Cantrill has a fantastic talk on this [1]). Others being uncompromising in these respects might come across as elitist or condescending.
I have seen a bit of that, but no more than in other language 'communities' (I mention Elixir and Clojure a few times here, because these are the most recent languages I've been a beginner in).
But that's not what I mean. I'm referring to the denial in the Rust community that it is difficult, when people are expressing the difficulties they are actually experiencing. The default position amongst Rust enthusiasts is simply to deny that the difficult thing is actually difficult. I have not experienced this anywhere else. You can even see it to some extent in the official tag line "A language empowering everyone to build reliable and efficient software". As this axiomatically applies to 'everyone', it logically follows that if you can't use Rust to build something or you're having difficulties doing so, you are either a bit dumb or lazy.
Now of course, if I really drew this inference merely from a marketing slogan, it would be a cheap shot. But I find it pointedly representative of the Rust culture at large. It is polite, and often fairly helpful, but there is a sort of glassy indifference towards struggle or friction. Asking questions online about Rust often feels to me like talking to a corporate rep.
[PS - thanks for the podcast pointer. Corecursive is in my subs but I haven't listened that far back. I shall]
Rust forces you to think of memory ownership. In turn challenging you to design more carefully your data structure and their relationship.
I think this extra effort is experienced differently by different people. But then comes the enlightenment. When you are comfortable thinking of ownership and pleasing the borrow checker without fighting.
And I wonder if sometimes people try to hide how long it took them before enlightenment. Or forgot how much work it was to update ones thinking.
My personal experience with the Rust community has been great. But it was also almost 9y ago. Things may have changed.
I haven't personally had any trouble with Rust's ownership model. It's pretty straightforward. I have found other aspects of the language and associated libraries difficult enough that I've made little progress with real projects. But that's not really relevant here. I'm more referring to the Rust community's characteristic cultural response to difficulties when they're raised, which seems (in my experience) to be first denial, then (generally polite) finger pointing.
> When you are comfortable thinking of ownership and pleasing the borrow checker without fighting.
That's kind of it. Saying "Rust forces you to think of memory ownership" is more accurate at the beginning, but not so much once you're experienced. Rust doesn't make me think about ownership: that's why the compiler checks it. It points out when I've made a mistake, and I move on. That I don't need to keep the rules in my head is kind of the entire point!
It's kind of both. I experienced this with Advent of Code, the other day where I had a vague idea of the data structure I was trying to work with, and the approach I wanted to take to solve the problem, but I started banging into errors from the compiler. I had to step back and take a moment to think about exactly what I was trying to do and what that meant for the model I was using.
My approach wasn't wrong and it likely would have worked on my first shot in Python or C# or something, but the fact that Rust cares about ownership meant I had to think about it too, even if I only really did that after the compiler pointed out that there were some issues.
I'm not quite sure why the Rust community is so dogmatic about the language's intrinsic excellence. I never found anything similar with the clojure or elixir communities (which each has its own distinctive style of response to beginner difficulties). My speculation is that Rust has such a strong inclusiveness mandate (which is a good thing in my view), that intrinsic difficulty is threatening to the group's identity. The impulse therefore is to deny the difficulty, from which it's a short step to pointing to the beginner as the source of the problem.