Lunduke and Rust: How Bias Leads to Nonsense

Let me start by saying that I am not a developer, I am a sysadmin who occasionally writes code, that being in Python, Laravel and Rust. I saw a lot of talk on Twitter from an account called "Lunduke Journal" about how the woke communist language Rust caused the internet to die for a couple hours.

Here is the first post made. Let's address this one - Rust does not feature a garbage collector and instead uses the borrow checker to drop variables when not in scope, which allows high performance without risking the same memory issues as in C, of which many view Rust as successor. Anyways.
In this Tweet, Lunduke claimed that this was a 'memory error' in Rust, the language which is not supposed to have them. There's also a screenshot from Cloudflare's own post-mortem which I will get to later.

Here, because Lunduke knows better than the Cloudflare engineers, he has highlighted a very specific part of the post-mortem instead of directing your attention to the already highlighted line of Rust code. Tragically, he forgot to include the 'avoid' in the line above.

Doubling down, Lunduke once again insinuates that this is an error which is only possible because it's Rust and not C.

What does Cloudflare have to say?

You can read the whole thing here: blog.cloudflare.com/18-november-2025-outage/, I will only go over the parts which Lunduke missed or left out.

For starters, a change in database permissions caused a job to fetch twice as much data as it should have. This went into a file which was then consumed by the Rust code which everyone is getting excited over. So, let's check the code:

The Rust function here read the file and got more data than it expected. The limit was set to a generous 200 but with the file now being much larger, when Rust tried stuffing so much data into the insufficient amount of pre-allocated memory, it generated an error.
Keep in mind that this error is not like a memory error in C with a null pointer or whatever. It is an error caused by a problem with memory, a distinction which Lunduke (probably innocently) omitted.

So, why did Rust "cause" this outage? Well because the dev used .unwrap() which basically says: if we got a proper result, hand it to the variable - if we got an error, panic. Rust is as much at fault here as Python would be if I did the following:

x = function_that_can_fail()

# when it should be:

try:
  x = function_that_can_fail()
except:
  # proper error handling

There's a distinction to be made, however, between Rust and most other languages, and that's the Result and Option types, which cannot be directly cast to your variable as they may contain an error and have to be explicitly handled. This means you are actually forced to handle the case where it could be an error. For example in some high quality production code I have:

// This returns a Result with either a list of pods or an error (eg perms err)
match api.list(&lp).await {
    Ok(pods) => pod_list = pods,
    // I handle it properly in prod, dw
    Err(e) => println!("Error handled here"),
}

In my opinion, this is a nice feature of the language and forces the dev to be aware to handle the potential error, as compared to C, Java, or even GO. Oh and you can easily have a linter to check for inappropriately handled errors (ctrl + f on unwrap) which is not as simple in other languages.

I assume these people are C purists and I wonder what would happen if you tried to load a file into insufficient memory. I haven't ever really written C so I don't know for sure. I imagine it could fail or it could not fail depending on what is overwritten in memory, and then the failure appears further down the line, making it harder to find the source of the issue.

My Armchair Expert Opinion

As is most obvious at this point, Lunduke heard that Rust was involved in a global outage and had to say that Rust is bad and how everyone who likes Rust is wrong. But then, what's to blame?

For starters, maybe the dev who wrote the unwrap() should instead have had some error handling instead of just panicking (though I do not know how you would even handle a situation like this one). The assumption was that so much memory wouldn't be needed; an assumption voided by an error further up the chain.
Another entity to blame would be QA for not catching the db query change which inflated the file size in the first place.
Another one is how the rest of the Cloudflare services were unable to handle an error in this service, which could have remained isolated and not cascade down to a widespread internet outage.
Last bit of blame could be that Cloudflare found the one Rust developer who is neither queer nor a furry. What were they thinking...

Lunduke is wrong and kept insisting on blaming Rust for a developer's mistake simply because it suits his audience of 'anti-woke' people who dislike Rust not for technical reasons but because its community is too diverse and colourful.
And while that's one valid lesson from this blogpost, another should be: the internet was made to withstand a nuclear war, but now cannot withstand a single company having downtime.