Hacker News Reader

Comment by jstx1 | Hacker News Reader

The Rust community is easily the worst thing about Rust. The constant preaching and cult-like reaction to any criticism is very offputting.

View on HN

I've had quite the opposite experience in fact. You can find numerous topics on places like r/rust where people talk about the downsides of the language compared to others (for instance).

I think this is the big difference. The tone in comments about /r/rust is dramatically different than the tone in /r/programming. I often see some pretty crazy RIIR evangelism in /r/programming.

I don't know if this is a comment about rust the language or reddit commenters.

/r/programming (and all of the other major generic programming subreddits) generally just do not have good conversation (or at least have much more noise to signal), as a large percentage of the community is very inexperienced. Same thing goes for non-programming, high subscriber count communities. You eventually get a lot of people who think they are knowledgeable about a topic because they've read a lot of topics on the subreddit, but they're really just inexperienced people parroting the opinions of other inexperienced people.

Even if you have some legitimate grievance, this sort of incredibly vague complaint tells nobody anything, it's completely uninteresting.

I've found there are two entirely different worlds within the Rust community.

Rust does attract a weird subgroup of people who can get preachy and pushy about there only being one way to do things.

But the helpful part of the community is much bigger and much better to work with. You just have to look past the loud people pushing agendas and stay out of flamewars on Reddit and HN.

It's the over-enthusiastic zealots. They're not unique to Rust. For example the golang community has equally defensive people who believe that Moses carved `if err != nil { return err }` as the 11th commandment, and anyone who wants less verbose error handling is an enemy of simplicity.

I have yet to run into the first type and I hope I never do. I’ve had such wonderful experience of people willing to help. Even big names like Steve Klabnik graciously offered some responses to my very elementary comments and questions.

The only community that’s been just as wonderful is the TypeScript community on Discord. Gosh they set the bar high for expectations on getting language help.

> The Rust community is easily the worst thing about Rust. The constant preaching and cult-like reaction to any criticism is very offputting.

I've seen more comments talking about this supposed phenomenon than instances of this phenomenon actually happening. I haven't really seen any examples of preaching and cult-like reactions, I just see people talking about how it supposedly exists somewhere.

Maybe it's a coincidence that people keep bringing it up.

Or maybe it's a meme at this point. I really would like to be furnished any examples of "cult-like" behavior from Rust users, because I have not seen any.

I've noticed a very big difference between comments about rust on general programming sites like here and /r/programming and comments in rust specific spaces. I find people in rust-centric spaces to be calm, reasonable, kind and pragmatic. Some of the worst rust evangelism I've seen comes from posters who I'm not even sure have written serious amount of it.

I agree with you that it can be really off-putting. From my perspective what you are seeing could be more of a comment on some of the know-it-all dilettante types who fawn over trendy tech in comment sections than the rust community itself. I've always had great experiences when reaching out for help in discords, user forums or other spaces. I've seen similar patterns with other trendy technologies in the past too.

At some stage there was a squad on StackOverflow who closed all Rust related beginner questions and it was impossible to get started. Most devs new to Rust do not understand &str and String and 99% of the content about is how implementation details backing those types are different. I have not seen any blog post, documentation about how and WHEN to use &str vs String.

I want to have a function that returns the UTC now as a string. Now what? Opening a question on SO -> question closed, here is a question about &str and String that has nothing to do with the use case and everything about the implementation details of &str. Good stuff.

I think the creator of Rust assume that if they explain where a piece of data is allocated suddenly everybody is going to be on the same page about the use of that data.

Rule of thumb: use &str when you don't need more than that, use String when creating text at runtime, returning from a function or storing it in a struct field.

Using borrowed values in general in fields is best avoided until you get more comfortable with the rest of the language.

Rust has no GC, so to use it you need to learn how memory allocation works. If you don't want to bother with those details, use a GC language instead of Rust.

If you are struggling to learn these things, even after working through the Rust book and other commonly cited resources, my suggestion would be to drop Rust for now and learn C. In C, pointers, stack/heap, malloc/free are things you have to deal with directly, so you can see how things work under the hood. And then, when you go back to Rust, you can map your hard-earned C understanding to the Rust abstractions

First off, Stack Overflow is super close questions happy. Asking a question without a minimum code example gets it closed before you can say MVP. Same for mark as duplicate.

> Most devs new to Rust do not understand &str and String and 99% of the content about is how implementation details

Looking at doc like this:

https://doc.rust-lang.org/rust-by-example/std/str.html

https://stackoverflow.com/questions/24158114/what-are-the-di...

Which part didn't convey the info you wanted? How would you convey it?

Curse of Knowledge is real, so to me it looks trivial, but I started Rust before str/String were a thing. I don't know what it's like to start learning Rust.

> I want to have a function that returns the UTC now as a string. Now what? Opening a question on SO -> question closed, here is a question about &str and String that has nothing to do with the use case.

That's on Stack Overflow overzealous moderation. If I had a dollar for every question of mine that was closed with mark as duplicate, I'd be a richer man. Doesn't mean it was specifically Rust community.

Did you consider Rust Discord? I asked few very technical questions and I got some really good answers.

> Curse of Knowledge is real.

I agree. I usually teach with example. Sort of here is a situation, this is your input now write something (a function, sql statement, etc.) to produce the desired outcome. While doing so I explain all the relevant details (this might be a good time to talk about different allocations for example).

This works surprisingly well. If you reverse the order (talk about different allocations first) the student need to connect the dots later.

I found my approach working better.

Anyways, it might be only me.

>> Did you consider Rust Discord?

I will try that.

Having been moderately involved in it, that isn't my impression. They were a helpful and informative bunch, and I learned a lot from them.

That said, being an outsider, I'm reminded of this quote from a recent article:

> "What was the deal with [person X] on your team, why are they such a jerk?" (Sadly, if you worked on Chrome you probably know exactly who I'm talking about.) The experience gave me an appreciation for how a group, especially a faceless internet group, can be perceived by its worst behavior.

Source: https://neugierig.org/software/blog/2022/12/chrome.html

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.

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.

> 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 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.

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.

[1]: https://corecursive.com/024-software-as-a-reflection-of-valu...

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]

My personal bigger issue is that at least some parts of the "community" often has a very harsh left to far-left swing to it that I've run into a couple of times that reacted with explosive hatred toward me when they realized I wasn't one of them. Yes I have some right wing views, I still want to use Rust though, but that doesn't mean I should feel forced to adopt your personal brand of far-left progressiveness. I hope that will even out given time.

It's kind of unnerving there even is a community as part of a programming language. I learned C from the K&R book and an old Russian guy.

I think it makes a lot of sense? A language has a surrounding set of commonly used and well adopted libraries for things that are common, but just not critical enough to get included within the standard library. E.g., having serde as a cornerstone for encoding/decoding means that, e.g., I can integrate with a decoder for complicated types easily, and I know how to do that independently of whether it's JSON, or TOML, or …. Having thiserror to help make rich error types.

C, admittedly, doesn't really have that. But I think that's mostly to C's detriment; projects have to sort of fill in those blanks themselves. Largely, I don't think they do: C libraries heavily prefer to return ints for errors, and I don't know that there are really "common" libraries out there? Certainly not to the same degree. (I wonder if the efforts didn't get focused onto higher level languages.)

Today, I'd mostly reach for C++ before C. Relatively¹ safer language, and the STL is far richer, and has basic data-structures that one requires for ordinary tasks. The situation is marginally better, e.g., there's boost, and the STL has seen some growth over time.

The downside, I'd say, is a single implementation and a looser spec, whereas C is standardized and runs on far more platforms.

¹and I mean relatively, as it is pretty trivial to utterly annihilate one's leg with C++

That's funny. My first programming 'community' was entirely comprised of computer magazines and a gruff alcoholic ex-academic who would occasionally throw a manual at me and bark corrections.

C community was originally on comp.lang.c and comp.lang.c.moderated, and there was this magazine thing called "The C User's Journal".

C is standardized by an ISO working group, and then there are multiple independent implementations. Rust is developed in the open, on GitHub by a single organization, which creates a single center for community to naturally aggregate around.

Same for the Go, Python, JS, Java communities. People will always try to “defend” what they like one way or another.

Also, what can you criticise about Rust? /s

I don't think it's the same for the languages that you listed, they seem much more pragmatic and willing to acknowledge flaws and tradeoffs. Maybe the Julia community comes close to Rust in the degree of cultiness.

I feel like the Rust community right now is being flooded by “fanboys” that have heard that the language is great for x and y (and x, y really are great probably), therefore they continue to push only those cool parts of the language but they didn’t even write a single line on code in production with it.

That’s why I’m saying that you find those people in most communities. Rust is just the trendy one right now so you just notice it more.

That's true in the limit - if you go in guns blazing then any community is going to get defensive. But I have found the Rust community to be uniquely thin-skinned. This is only one person's experience, I can't provide any real evidence beyond my own memory of interactions.

Crude sketches of my experience presenting beginner difficulties to a few communities:

Clojure: "yes, clojure does tend to be used largely by experts, which can present some difficulties", followed by many friendly suggestions about how to get there

Elixir: "you're having trouble? Hmm that's not good. Try this for now, and let's see what we can do to improve matters"

Rust: "no, you're mistaken, nothing in Rust is difficult if you're smart or hard-working enough"

> uniquely thin-skinned

I have not found that. Occasionally, but rudeness, bullying, and intolerance is not tolerated.

Compared to the GNU world. Try reporting a bug in Emacs. "You complete idiot". Or Dog help us: OpenBSD.

Politeness and receptiveness are entirely orthogonal qualities. The Rust community is indeed mostly polite. That's a good thing I think, but it can paper over a good deal of dismissiveness (expressed as politely as a Victorian men's club sneer).

> Rust: "no, you're mistaken, nothing in Rust is difficult if you're smart or hard-working enough"

I feel the need to mention that that attitude isn't welcome in any of the communities I participate in and I make sure to call it out when it does rear its ugly head. Personally I bend myself backwards to try and meet newcomer developers where they are when it comes to the way the compiler uses diagnostics.

The closest I can think of to this attitude being prevalent is "what are you trying to accomplish (because the way you're trying to do it is going to be harder than you're ready for yet)?", which doesn't mean "you're stupid/not hardworking" but rather "there's collective wisdom about how to work in the confines of the borrow checker, and going against the grain while also learning the language will put you off the language".

Well it's common on the Rust user forums in my experience. I had intended to have a good stab at Rust in 2022 as I typically learn a new language per year (to varying degrees). Having failed to really get on very well with it I'm going (for the first time) to continue for a 2nd year and try Rust once more in 2023. But I don't plan to engage with the Rust community again - there are lots of great learning materials around and I'd rather go it alone than run the smug superiority gauntlet.

Strange, I haven't seen that on r/Rust or the various Discord servers. Honestly, I've seen more of that kind of attitude in C/C++ circles

>The Rust community is easily the worst thing about Rust.

Completely agree, but for a different reason:

The community and leadership is overran with woke leftist types. It's insufferable.

As someone who both loves Rust and is very much anti woke leftism, I don't think it's a huge concern at present. Much of the leadership happens to be woke but it doesn't get in the way of technical discussion. That could change, of course, but for now it's not causing problems

Yep. Just search “borrow checker” on their subreddit. Any post pointing out an instance where it makes things overly verbose and complex is immediately met with downvotes and “why do you need to do that”s.

They forget themselves how it was for them at first (the curse of knowledge). New comers might even get onto the train and pretend they know better for appearance's sake. Murking the water.

Remember if you know better than the borrow checker you can use raw pointers. There is very little friction. But are you sure you can do better without the safety of the borrow checker having your back?

Raw pointers in rust are a pain to work with. This rust code is significantly less verbose in C++:

https://play.rust-lang.org/?version=stable&mode=debug&editio...

Rust purposely handicaps ergonomics, even when it wouldn't come at the expense of safety. This is just one example. Rust also doesn't have function overloading, default arguments, named parameters, anonymous structs, unwrap sugar (like !! in kotlin), etc. Rust's aversion to user choice precisely what is hampering its adoption. Docker and kubernetes are written in go. Unreal engine, high frequency trading systems and most of google is written in C++. What significant thing has been written in rust? it's forever going to be a hobbyist language competing on stackoverflow surveys instead of actual large-scale applications. Nobody with any actual money on the line wants to take the hit in productivity to switch to rust, at most it's used for a small part of a larger project written in another language. By the end of the decade there's going to be more things written in carbon than in rust, and that sucks because it was completely preventable.

One has to start somewhere,

https://security.googleblog.com/2022/12/memory-safe-language...

https://twitter.com/dwizzzlemsft/status/1578532292662005760?...

https://devclass.com/2022/06/21/rust-applications-previewed-...

https://aws.amazon.com/fargate/

https://krustlet.dev/

https://github.com/EmbarkStudios/rust-ecosystem

https://research.activision.com/publications/2021/09/the-rus...

Carbon is still an AST interpreter with half baked language design, and it remains to be seen how many of the features are to be designed.

From Carbon, Val, Cpp2, Circle, the last one is the only one that has a chance to actually provide a proper migration path from classical C++.

If I would have to put money in any of those wannabe C++ replacements, Circle would be it.

I tested that out and mostly only found positive, constructive comments. I only found 2 cases of someone complaining about verbosity though. Searching "borrow checker verbose" doesn't give many results with complaints.

Can you link some examples?

They don't have to be complaining about verbosity, it will suffice to just have an example where the borrow checker gets in the way to be met with downvotes.

https://www.reddit.com/r/rust/comments/z3gwag/circumvent_bor...

https://www.reddit.com/r/rust/comments/y20wqd/fighting_the_b...

https://www.reddit.com/r/rust/comments/vyr8im/help_with_maki...

https://www.reddit.com/r/rust/comments/ttzb5w/how_to_deal_wi...

https://www.reddit.com/r/rust/comments/vhcuhe/help_need_help...

https://www.reddit.com/r/rust/comments/ufviu4/question_lifet...

https://www.reddit.com/r/rust/comments/red1f9/borrow_checker...

https://www.reddit.com/r/rust/comments/ozruff/help_with_borr...

You can also try searching "linked list" or "graph". And here are some bigger posts that are genuinely critical, met with the typical rustacean response:

https://www.reddit.com/r/rust/comments/rylrma/im_losing_hope...

https://www.reddit.com/r/rust/comments/xj2a23/my_thoughts_on...

https://www.reddit.com/r/rust/comments/xryi2n/opinion_rust_h...

https://www.reddit.com/r/rust/comments/s75wd9/a_c_perspectiv...

As someone else has stated, you have not said anything of value here and are just vaguely screaming into the wind. Do you just find people being highly enthusiastic about something off putting? If so, do some introspection.

Reply on news.ycombinator.com