Interesting take, those bugs are more convenient to exploit. Logic bugs are too specific to easily exploit at scale.

Definitely this. C++ isn't going away anytime soon. Rewrites won't be worth it in important cases, so improving the safety of the language matters.

If you needed to be reminded that allocating small blocks of memory is a bad idea... here is a paper explaining it.

Interesting dive into how join() and generator behave in CPython.

Interesting quick comparison, this shows the design tradeoffs quite well.

Interesting case... even though honestly we shouldn't need to dig out this kind of details.

Improved static analysis for C straight from GCC. This is definitely welcome.

This is indeed a more interesting way to perceive garbage collection. This also lead to proper questions to explore on the topic.

Nice balanced view on some of Rust characteristics. This is much less naive than some of the "Rust is great" posts out there.

Making your own allocator? This is definitely something to consider and measure.

Excellent piece from Herb Sutter once again. This is a very well balanced view about language safety and how far C++ could go in this direction. This is a nice call to action, would like to see quite some of that happen.

Indeed, not all security issues are due to memory related problems. It's 20% of the security issues. This is of course massive, but there's still 80% of the security issues coming from wrong authentication, appliances and so on.

Very interesting talk. It gives a good idea of some properties of the JVM memory model. It also shows how the CPU architecture properties can leak all the way through changing some of the behavior of JVM code. Too bad this particular thing seems badly documented on the JDK side.

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.