Very interesting musing about undefined behaviors and language constraints. This is a bit Rust focused for obvious reasons but is also looking at what other languages have been doing.

Nice approach to also hunt for memory safety issues while software is in production.

I didn't read it since it's basically a whole book. Still from the outline it looks like a very good resource for beginners or to dog deeper on some lower level topics.

A bit C++ and game engine focused (to be expected since this is were this kind of techniques originate from), bit very good explanation on how to have packed layouts for your objects and reduce pressure on memory allocation for data intensive tasks.

This is an interesting idea, I think I'll try it to see how it impacts my memory.

Long but fascinating article on a blend of guidelines which could be statically checked to enforce a memory-safe subset of C++.

The title of the post is not the best. Still it nicely lists and explains common mistakes around the use of std::shared_ptr.

Deep dive on a proper benchmarking and implementation for 1M task on the Erlang runtime. Clearly the previous benchmark had room for improvements.

Indeed, the story of integrating C and C++ with Rust isn't a simple one right now. It might introduce larger attack surfaces. Some improvements are proposed in this paper.

Everything you always wanted to know but didn't dare asking about memory allocators. OK, maybe not "everything everything" but this gives a very good overview on how they work and the trade-offs they have to make.

Doesn't give the whole picture (memory isn't the only important parameter) but interesting results nonetheless. A few surprises in there, Java and C# do much better than one might assume for instance.

Often overlooked in test cases. Still it's not that complicated to setup.

Interesting approach. There's still a lot we can achieve with static analysis in those good old languages.

I very much agree with this. It is a real concern with our industry, we seem indeed to keep reinventing the wheel a lot. How do we stop forgetting? How do we move forward?

Interesting set of memory patterns. Didn't know all of them, some are definitely useful and I already use, I'll try to look for the others next time I need to.

Very good overview about RAII, ownership, borrowing references. All that comparing C++ and Rust in their ways to handle those concepts. Definitely a must-read even though it's a bit long.

Good explanation of the relationship between memory and learning... it's not quite what one would intuitively think, things need to be in long-term memory first which means you need to repeat things somehow so that they end up there (otherwise they're just in the temporary working memory).

OK, it's 2022 and this is still not an adequate ecosystem for system programming.

Excellent deepdive about pipes, on the path to optimization we see how perf is used, how memory is managed by the kernel etc. Very thorough.

That looks like a very interesting tool for larger Python based projects. Definitely need a way to profile memory use in there.