The Rust Evangelism Corollary

Level 1: Shiny New Toy

Imagine you’re in a playground and there are lots of different toys to play with. Usually, kids have two reactions to a toy:

1. Everyone plays with it, so they also complain about it – think of a super popular video game or toy that all your friends use. Because everyone’s playing with it, you hear them whine about little things: “Ugh, this game levels up so slowly!” or “This toy car’s battery dies too fast!” When something is really popular, people both love it and love to grumble about it because they use it so much.
2. No one plays with it, so there’s nothing to complain about – imagine a toy that’s sitting in a corner that almost nobody picks up. If nobody is playing with it, you won’t even hear any complaints or opinions. It’s like it doesn’t even exist in their minds.

Now, let’s say a new fancy toy comes along – let’s call it the Rust Rocket. This Rust Rocket is really cool and a bunch of kids start saying it’s the best toy ever. Surprisingly, you don’t hear kids complaining about the Rust Rocket breaking or being boring. It actually works really well and everyone who uses it seems to love it. Instead, something funny happens: other kids start complaining about the kids who won’t stop talking about the Rust Rocket! They say things like, “Gosh, those Rust Rocket kids are always bragging about how great their toy is. It’s so annoying!”

So in simple terms:

• If a toy is super popular, kids will both play with it and complain about it a bit.
• If a toy is not popular at all, kids don’t talk about it (no complaints because no one’s playing).
• But this special Rust Rocket toy is popular and works so well that kids aren’t complaining about the toy. They’re complaining about the fans of the toy, because those fans keep telling everyone how awesome it is.

It’s a silly cycle, kind of like an infinite loop of complaining: no matter what, if something becomes popular, kids (or people) will find some way to complain – if not about the thing, then about the people who like the thing a lot. That’s why this is funny: it’s saying even the best toy (or programming language) can’t escape playground gossip. The toy itself might be great, but if its fans won’t quiet down, other kids will roll their eyes and start teasing the fan club instead! In the end, it’s all in good fun – just kids (or developers) being a little bit cheeky about each other’s favorites.

Level 2: Language Love & Hate

Let’s break this down in simpler terms. The meme is about programming languages (like Python, Java, C++, JavaScript, or Rust) and how developers talk about them. There’s a well-known saying among programmers that goes: “There are two kinds of programming languages: the ones people complain about, and the ones nobody uses.” What does that mean? Basically:

• If a programming language is widely used, people will always find something to complain about. This is normal because more users means more chances to run into things that annoy them. For example, many developers use JavaScript for web development, and you’ll often hear them joke or complain about its odd behaviors (like how 0 == "0" is true, which is weird!). Similarly, Java is super popular, and folks gripe about how verbose it can be (you have to write a lot of boilerplate code to do simple things in Java). Python is loved, but people complain it’s slow for certain tasks, or that it has the Global Interpreter Lock (GIL) which makes multi-threading tricky. In other words, no popular language is perfect, and developers love to poke at each one’s weaknesses. It’s almost a hobby in the tech community to playfully bash whatever tool we’re using – because we use it so much, its flaws are well-known.
• If a language has no complaints around it, that usually means hardly anyone is using it. It might be a very obscure language or one that’s mostly academic. For example, there are niche languages taught in universities or used by a tiny group of enthusiasts – you won’t find big Reddit threads ranting about them simply because very few people write code in them day-to-day. No users, no complaints. So that part of the saying is basically: “If nobody is griping about a language, it’s probably because nobody is writing code in it (outside perhaps a classroom or experiment).”

Now, the meme’s twist is introducing Rust into this picture. Rust is a relatively new programming language (first released in 2015) that has become quite popular, especially for systems programming (kind of like C++ territory). Rust is designed to be safe and fast – it prevents a lot of common bugs that happen in languages like C/C++ (like crashes due to memory errors). Because of these guarantees, Rust has gained a reputation for being very reliable. Many developers love Rust for these reasons; in fact, in surveys Rust has been rated the “most loved programming language” for multiple years. The meme points out something interesting: when developers talk about Rust, they don’t complain about Rust’s features as much as they do for other languages. You won’t frequently hear, “Oh Rust’s memory management is so awful,” because Rust actually fixed a lot of the traditionally awful things! Instead, what happens (and this is the joke) is people start to complain about Rust’s users. 😆

Why complain about Rust’s users? This is referencing the perception that Rust developers can be a bit... enthusiastic or evangelical about Rust. Rust’s community is known to be very passionate. Sometimes, on tech forums or social media, if someone asks “What language should I use for this project?” you’ll get a chorus of Rust fans saying “Try Rust, Rust is amazing for that!” even if the question wasn’t specifically about Rust. They mean well – they truly like the language and think it could help. But to outsiders, it can come across as Rust fans popping up everywhere to push their favorite tool. This has led to a stereotype that Rust programmers are always bragging about Rust or trying to convince others to use it. Some people find that a little annoying or tiring.

So, the second comment “And then there’s Rust” implies Rust is a special case beyond the original two kinds of languages. And the third comment explains that special case: Rust is the language where, instead of criticizing the language itself, people joke about or criticize the behavior of its community. It’s like saying, “Rust (the language) is fine; what’s not fine is how smug or preachy some Rust users can be.” Of course, this is a generalization and said in jest – not all Rust programmers are like that! Many are friendly and not pushy. But in humor, we exaggerate a bit. The meme captures a lighthearted jab at Rust’s fanbase and the whole pattern of programming “language wars.”

To recap in simple points:

• Popular languages = lots of complaints (because lots of people use them and find issues). Example: Tons of devs use JavaScript, so you’ll hear frequent jokes about its weird parts.
• Unpopular or little-used languages = no one complains (because hardly anyone encounters them to care). Example: A language used by a tiny group will fly under the radar with no one discussing its faults publicly.
• Rust = people don’t complain much about Rust’s design (since it’s well-designed to avoid many common problems)… instead, some complain about Rust’s users (because Rust’s biggest fans are very vocal, which itself becomes a talking point).

This is poking fun at how developer conversations often shift from technical issues to community issues once a language gets a devoted following. It’s a bit like in pop culture: a new band comes out and everyone loves their music (nothing to complain about there), but if their fans become overly zealous (“This band is the best ever! If you don’t listen to them, you’re missing out!”), other people might start rolling their eyes at the fanbase, not the music. In tech terms, Rust is that hot new band, and some folks are eye-rolling at the “Rust superfans” more than at Rust itself.

The meme sits in the Languages and DevCommunities category because it’s not just about a programming language’s features – it’s about the community culture around languages and how developers interact, joke, and sometimes clash. The tags like LanguageWars or DeveloperRivalry hint at these long-running friendly feuds: it’s common to see debates like “Java vs. Python” or “Tabs vs. Spaces” or “Emacs vs. Vim” that never truly get resolved but provide endless fodder for humor. Rust has now entered the fray, but with a twist: the “war” isn’t attacking Rust’s capabilities (since those are widely respected), it’s poking at the Rust evangelism phenomenon.

In summary, for a junior developer or someone new to this:

• Don’t take the meme as an actual knock on Rust’s technology – it’s more of a cultural joke.
• Understand that every programming language, once it’s popular, gets criticized (often jokingly) by developers because we all love to rant about our tools’ shortcomings.
• Rust so far has dodged a lot of the typical technical criticism, so the jokes have shifted to teasing the people who can’t stop praising Rust. It’s like a gentle roast: Rust is great, we get it, but hearing that for the 100th time, someone will inevitably joke “the worst part of Rust is its fans.” 😅
• This meme reflects the dynamic nature of developer culture where the target of humor can evolve over time – from languages themselves to the communities around them as those communities grow big and vocal.

Level 3: The Rust Exception

The meme highlights a legendary adage in programming culture and then throws in Rust as a curveball. The first comment quotes a famous line (often attributed to Bjarne Stroustrup, creator of C++):

Commenter 1: “There are only two kinds of languages: the ones people complain about and the ones nobody uses.”

This wry Stroustrup’s Law suggests that if a language is popular (like C, Java, Python, JavaScript), developers will relentlessly complain about its quirks and flaws. We complain about JavaScript’s type coercions ("5" + 3 -> "53"!), Java’s verbosity (FactoryFactoryFactory classes galore), Python’s GIL slowing down threads, C++’s template errors, and so on. These grievances are practically a rite of passage for widely used languages. And if a language has no one griping? It’s probably so obscure or unused that nobody even encounters its problems (think of an esoteric language like Brainfuck – fun name, but ~nobody writes their startup in it, so no forums full of rants). In essence, widespread use and widespread gripes go hand in hand. Complaints are almost a sign of success: your language is relevant enough that its pain points annoy a lot of people daily. Conversely, if a language isn’t used, there’s no community to even find its faults – silence implies irrelevance.

Then along comes the second comment with 64 upvotes, cheekily adding:

Commenter 2: “And then there’s Rust.”

Ah, Rust – the systems programming language that’s been the darling of open-source surveys for years (boasting the “most loved language” title on Stack Overflow multiple times). By invoking Rust, the commenter implies Rust doesn’t neatly fit Stroustrup’s two categories. Rust is indeed widely used in certain domains (systems programming, web assembly, blockchain, embedded, etc.) and widely praised for its technical merits – yet you don’t hear the same kind of complaining about Rust’s design that you do for, say, C++ or Java. It’s as if Rust is escaping the usual law: people aren’t griping about the language itself nearly as much as you’d expect for something so popular among developers. No endless threads about “Rust is too slow” or “Rust’s syntax is garbage” – in fact, Rust is admired for solving longstanding headaches (memory leaks, data races) with an elegant but strict compiler (the borrow checker). It’s like Rust eliminated entire categories of common bugs, leaving less to complain about on the technical front. So is Rust an exception to the “complain or unused” dichotomy?

The third comment (128 upvotes) delivers the punchline by clarifying Rust’s true place in this equation:

Commenter 3: “Yeah, that’s the one where you complain about the people who use it rather than the language itself.”

Boom – Rust isn’t a free pass from complaining; it just shifted the target. Instead of nitpicking Rust’s code or design, the discourse often turns into grumbling about Rust’s community and its evangelists. 😅 In other words, Rust is so well-engineered (or so new) that haters struggle to find serious technical faults, so they go after the Rustaceans (Rust developers) instead. This comment nails a truth in developer culture: when a language gains a passionate, and sometimes zealous, following, the tone of complaints changes. It’s no longer “Ugh, Rust’s borrow checker is annoying” (though you’ll hear that from some learners); it’s more often “Ugh, Rust fans are annoying, they think Rust is the answer to everything.” Essentially, Rust introduced a third category of language in this joke taxonomy:

• Languages people complain about (JavaScript, Java, C++, etc. – established giants everyone uses and bickers over).
• Languages nobody uses (the ones that remain niche academic curios or super specialized – no usage, no complaints).
• Rust: the language whose biggest “problem” is the unbridled enthusiasm of its users.

This is a commentary on developer communities and hype. Rust’s community has a bit of a reputation in the broader dev world. They’re often enthusiastic, vocal, and everywhere online singing Rust’s praises. Many Rustaceans genuinely love their toolchain – memory safety without a garbage collector, fearless concurrency, modern syntax – and they can’t help recommending Rust for every problem under the sun. This fervor, while coming from a positive place, sometimes rubs other developers the wrong way. It can come off as smugness or a “cult of Rust” to those outside of it. We’ve seen this pattern before: for example, back when Ruby on Rails was new and shiny (~2008), its devotees touted “Rails magic” so much that dev forums got fatigued by Rails hype. The same happened with Node.js, Docker, and many hyped technologies – a subset of fans become ultra-zealous evangelists, which spawns a counter-backlash of people rolling their eyes. Rust is simply the latest tech to hit that point on the hype cycle: its technical strengths are undeniable, but the cultural backlash isn’t about Rust-the-language, it’s about not wanting to hear one more “Have you rewritten it in Rust yet?” joke or essay.

So the humor here is a bit meta: the community’s high enthusiasm effectively created new fodder for complaints. We’ve gone from complaining about code issues to complaining about people issues. It’s a tongue-in-cheek acknowledgment that in the world of programming language debates (often called language wars), even a near-“perfect” language can’t escape negativity – that negativity just finds a different target. In Rust’s case, the infinite loop of complaining continues, but it’s pointed at the Rust fanboys/girls rather than Rust’s compiler or performance. It’s as if the meme says: “All languages get complaints if they matter; Rust matters so much that we’ve moved to the next level – complaining about Rust developers.”

From a senior developer perspective, this rings true and is darkly humorous. We’ve all witnessed endless flame wars on forums and Twitter: if it’s not one side bashing a language’s garbage collector or lack of types, it’s them snarking about how insufferable the other side’s community is. Rust is just at that awkward adolescent stage of popularity where its reputation is half stellar technology, half overzealous fanbase. Seasoned devs see the pattern:

1. Early Adoption Phase: A language is new, promising, and has a small tight-knit community (no complaints outside, because nobody else knows it).
2. Growth Phase: Language gains popularity; people start using it in production. Inevitably, warts are discovered and loudly discussed (complaints ramp up – “X is great but why does it do ____?!”).
3. Fanboy Phase: The language becomes a hot trend. Fans become evangelists. Detractors get annoyed not only by any real issues but also by the constant hype from fans.
4. Backlash Phase: Instead of technical debates, it devolves into culture war. People stereotype the typical user of the language: “Oh, you’re a Rust programmer, you must think you’re so clever with memory safety.” Technical merit discussions sometimes get drowned out by these meta-arguments.
5. Maturity Phase (maybe years later): Eventually, the hype normalizes, the community broadens, and the language becomes just another tool – people accept both its strengths and flaws. (By then, a new language probably restarted the cycle elsewhere.)

Rust in late 2021 (when this meme was posted) is entering Phase 3-4 in this cycle. It’s popular enough that lots of programmers encounter Rust advocates even if they don’t use Rust themselves. Thus, complaining shifts from Rust’s steep learning curve or long compile times (real issues but often overshadowed) to poking fun at Rustaceans always talking about Ownership and lifetimes at every coffee break. Developer rivalry and language evangelism have simply taken a personal turn: it’s easier to tease the “Rust fan club” than to attack Rust’s solid technical design. This happens because technical arguments against Rust often end in “actually that’s a deliberate choice to ensure safety, here’s a 10-page blog,” which is exhausting. It’s faster to just say, “Ugh, Rust users are so pretentious.” It’s a kind of ad hominem shortcut in language wars – when you can’t win on facts, you joke about the people. And frankly, Rust folks sometimes do proudly wear that “Most loved language” survey result like a badge, which only fuels the fire 😜.

From an architectural standpoint, one might even argue Rust’s biggest “flaw” is being too effective at eliminating classic flaws! It doesn’t have null-pointer dereferences (no more dreaded NullReferenceException), it has no data races thanks to its compiler rules, it has modern ergonomics… where’s a veteran complainer supposed to stick their dart? The remaining targets are niche (e.g., complex syntax for lifetimes, which mostly bothers new adopters) or intangible (tooling maturity, which isn’t fun to meme about). So instead, the broader dev community makes jokes about Rust’s culture. This parallels how people mock say, Apple fans instead of nitpicking the hardware, or sports fans rather than the team – it’s humor derived from tribal identity.

In summary, the meme is comically extending Stroustrup’s Law with an edge: if a language becomes beloved enough to avoid major criticism, the complaints will target the love itself. It resonates with experienced devs who have seen these cycles play out. It also pokes at Rust’s unique position: admired technically, yet provoking a side-eye because of how ardently its devotees preach. It’s the infinite loop of tech discourse – as long as something is popular, we’ll find something to gripe about, even if we have to switch from the technology to the people behind it.

For the more code-inclined, here’s a cheeky pseudocode representation of this language complaint cycle:

languages = ["C++", "Java", "JavaScript", "Python", "Rust", "Haskell"]
for lang in languages:
    if lang == "Rust":
        print(f"Rust detected. Complaining about Rust developers instead of {lang}.")
    elif is_widely_used(lang):
        print(f"Complaining about {lang}'s quirks and flaws.")
    else:
        print(f"{lang} is niche. No complaints (nobody uses it).")

Running this would output something like:

Complaining about C++'s quirks and flaws.
Complaining about Java's quirks and flaws.
Complaining about JavaScript's quirks and flaws.
Complaining about Python's quirks and flaws.
Rust detected. Complaining about Rust developers instead of Rust.
Haskell is niche. No complaints (nobody uses it).

As you can see, Rust creates a special case in the loop – exactly as the meme jokes. And true to form, that loop could go on forever as new languages rise in popularity: the targets of complaints shift but the act of complaining never ends! It’s an infinite loop in developer culture.