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.
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.