Interesting comparison between C++ and Rust for a given algorithm. The differences are mostly what you would expect, it's nice to confirm them.

A bit dated perhaps, and yet most of the lessons in here are still valid. If performance and parallelism matter, you better keep an eye on how the cache is used.

Interesting advanced features of GraalVM to better manage the memory of complex Java programs.

Security asks for more than a memory safe language. It helps some things for sure, but there are tools for other languages as well, you better start using them.

Nice little trick to get rid of some malicious bots.

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.

This is indeed a nice tool to explore and check the memory layout of data structures.

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

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.

This could be a big improvement for C. We'll see how far this goes.

OK more questions than answers I guess... That said, it shows interesting differences in design choices with C++ to support the traits system.

This is an important concept in Rust... but clearly it's harder to grasp than you'd expect.

They help with some issues... but they can't solve all the memory safety issues of the language I'm afraid.

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.

What do you want? Speed or safety? Ultimately you'll have to choose one.

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.

If you didn't realise that null pointers open a maze of different traps, this is a good summary of widespread misconceptions.

Looks like there is a new venue to improve garbage collectors performance. This should be interesting down the line.