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.
OK more questions than answers I guess... That said, it shows interesting differences in design choices with C++ to support the traits system.
Interesting reasons to let go of Rust, some spaces indeed can have a safety vs performance tradeoff which would justify using good old C.
This is an important concept in Rust... but clearly it's harder to grasp than you'd expect.
A long piece which explore the reasons why Rust is likely not the best pick for enterprise software. It's niche is clearly system programming but beyond that and because of its qualities in that space it quickly become a sharp and dangerous tool.
Interesting comparison. Ada doesn't fare as good as I'd have expected as soon as pointers are in the mix... but there is a twist, you can go a very long way without pointers in Ada.