A reminder that small details at declaration can have large impacts on memory layouts.

No, don't go assuming you can use disks instead of ram. This is not what it is about. It shows ways to get more out of your disks though. It's not something you always need, but sometimes it can be a worth endeavor.

Interesting notes about borrow checking in Rust. Looks like it does a good job exploring the whole space of issues one can encounter with potential solutions.

Just a little dive in the Rust standard library. It gives a good idea on how they pile layers to ensure safety while providing a nice API on top.

Interesting dive into an heisenbug... Definitely not easy to debug.

Due to the strict type system this kind of conversion is not necessarily a given. There are ways though, and you can even keep it performing well.

This is an interesting and deeply buried optimization for the GNU C++ STL implementation. I didn't expect anything like this.

No good tricks to optimize your code, but knowing the tooling knobs sometimes help.

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.