I used to do that, fell into the "taking notes on the computer". And clearly it's not the same, I'm thinking going back to paper notebooks soon.
Looks surprisingly easy to profile the Django startup. Probably makes sense to profile other parts of your application but this is likely a bit more involved.
Nice introduction of the C++ ownership system. Nothing new under the sun obviously but since I still encounter developers struggling with this, such introductory material is nice to have handy for sharing.
A good reminder that allocators generally do more than you expect.
Careful of undefined behaviours. They can be reached fairly quickly. Especially in C++ and its initialisation maze.
Another explanation for the rule of zero in C++. We should definitely stick to it.
Excellent resource for keeping an eye on performance issues in your codebase. It's very C++ oriented but most of the insights can be generalised to other ecosystems.
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.