Or why I'm still on the fence regarding async/await. It's rarely the panacea we pretend it to be.

Another trick in Rust to avoid unwrap() calls. The let-else option is indeed particularly elegant.

Apparently this needs pointing out but there's more than async/await out there. Sometimes what you want is a simple event loop. Here illustrated in the Rust ecosystem.

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.