Indeed, CPU prefetchers are really good nowadays. Now you know what to do to keep your code fast.

Interesting point, fairly logical but didn't sit to think it through before. Indeed, using arenas to get back features of manual memory management won't lead to the same security issues than outside of a memory safe language.

Dealing with temporaries is always complicated it seems, whatever the language.

I think this is indeed something still easily overlooked. You can deal with this kind of intertwined lifetime issues using shared_ptr.

The memory models for GPU programming are complex. This isn't easy to squeeze more performance without introducing subtle bugs.

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.