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.

A good example of what can be done when you have a rich type system.

Another reminder that you don't want reference to primitive types everywhere in Rust code. There's actually ways to handle this properly. This post gives a couple of simple guidelines to apply.

A harsh reminder that getenv is not thread safe...

Very nice explorations of the different behaviours type systems can have around inference.

Interesting article. There's clearly space for both languages indeed. They'll end up having each their own ecological niches, probably with some overlap.

A bit long and a bit too much framed in a "vs Python" fashion for my taste. That said it contains good advice on how to prototype or start simple with Rust. It's aligned with some of the advice I give as well. People tend to turn to low level details too quickly forcing themselves into a corner. There are better ways to handle it.

More studies needed to confirm this, it is a single data point. Still it looks like Rust could take the HPC world by storm once it gets a better GPGPU story (still early days there).

Interesting explanation of a research paper exploring the possibility of a faster SQLite by focusing on async I/O.

Good explanation of what Rust's unsafe really does.

This is a good view of what you're getting into with the "rewrite it in Rust" knee-jerk reaction.

Interesting progress on safe type casting in Rust. This should bring nice zero copy parsing of binary data in some cases.

Nice article showing the steps to port Rust code to run on deeply embedded systems. It highlights the difficulties and caveats of such a task.

Interesting comparison of the different choices made in Rust and the upcoming C++26 for code generation. It's fascinating how they managed to have such facilities in Rust while having no introspection. C++ going the opposite direction will have a very different feel both in term of use or of implementation.

Excellent proof of why you don't want to "rewrite it all in Rust". It's important to respect the old code and focus on applying safety practices on the new code. This is also why the upcoming changes to C++ are worth it, it might improve the interoperability factor almost for free.

Despite the drama, Rust is slowly making its way into the kernel.