I find the title misleading. Still, this is a good exploration of how to treat unwrap() and expect() in Rust code.

Not a huge fan of the writing style. Still this gives a good idea of what you have to deal with when you're trying to build lock free data structures. Here it's illustrated with Rust, but it's not Rust specific.

There's clearly a tension between security and ease of pulling dependencies. In a way, it's "too easy" with cargo and you very quickly end up having to trust a staggering amount of third party code.

Nice docker recipe indeed for small and secure containers when you just want to ship a statically linked binary.

A nice example which shows the value proposition of Rust is not simply memory safety. Having a stricter type system and properly designed based types help a lot to catch mistakes early.

Good advice on how to learn Rust. I recommend quite some of it.

Looks like a nice tool to navigate mistakes with Rust complex type system.

Mutable vs immutable is a good first approximation... but it goes further and this little article does a good job explaining why.

This is a nice little experiment. Not statistically relevant (there are other papers for that), but shows in the details how introducing Rust can impact the way people work. This is interesting because it means the safety gains are not only strictly coming from the (now infamous) borrow checker. We can't rely on everyone applying all the techniques necessary but for sure they're cheaper to put in place than with C.

The concept of allocators in general and arena allocators in particular is too little know. Here is a little article which rediscover the motives behind them. It's a good introduction to the topic.

If you forgot that the memory allocator can matter greatly depending on your workload.

Nice tutorial for rendering water. It gets more complex from there but this one is doing quite a lot already.

Interesting stuff. This should ease greatly sharing code between shaders and the host application, especially for data specification which is easy to get wrong.

Sure, you get good memory safety with Rust. It's important and welcome, but it's just the beginning of the story.

Interesting trick to check at runtime that you always acquire mutexes in the same order.

Nice feature, but more interesting in its explanation is the topic of static initializers in Rust. They're clearly not a settled area in the language, that's in part because of how low level static analyzers are.

Rust itself might bring interesting properties in term of safety. As soon as it needs to interact with other languages though the chances of undefined behavior increase drastically. This definitely pushes towards using more dynamic analysis tools to catch those.

A good look back at parallelisation and multithreading as a mean to optimise. This is definitely a hard problem, and indeed got a bit easier with recent languages like Rust.

Looks like there's movement at the Rust Foundation level to have better C++ and Rust interoperability. We'll see what comes to fruition, this could be interesting. It's needed for sure.

A quick primer about compile time evaluations in Rust.