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.

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

Data layout is essential for performance reasons. It is too often overlooked. If you want real speed you need to help the memory subsystem.

Good reminder that packing your data is generally the right move when squeezing for performances.

Interesting point. As the memory safety of our APIs will increase, can we reduce the amount of sandboxing we need? This will never remove completely the need if only for logic bugs, but surely we could become more strategic about it.

Funny musing about the OOM killer. With nice pointers if you want to dive further into the topic.

There are many ways to create a memory leak in Javascript. Here is a good list of the things to pay attention to.

Interesting, it confirms garbage collectors can be the source of unrecoverable performance degradation in request based systems.