If you needed a reminder that inlining functions isn't necessarily an optimisation, here is a fun little experiment.

Looking at several languages and their reflection features. What's coming with C++26 is really something of another class than anything else. I just have concerned about its readability though.

Looks like an interesting tool to follow availability of C++ features in compilers.

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.

This piece is (unsurprisingly) biased. Still there's some truth there. C++ is here to stay, like it or not. The safety issues are overblown and are getting addressed. Now where the article is lacking is that the language has other issues. Also, will profiles ever become a real thing?

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.

I definitely agree there. It looks like a missed opportunity to improve the API and nudge people in the right direction.

Definitely the right rule to follow to designing classes in C++ in my opinion.

It's indeed fairly underrated but very useful, especially if you're making libraries.

A reminder that small details at declaration can have large impacts on memory layouts.

It's all written oriented toward C++ use. That said I think most of it equally applies whatever the language.

An old one now, but still a very good overview of what C++ ranges brought to the table.

Good list of hardening options indeed. That's a lot to deal with of course, let's hope this spreads and some defaults are changed to make it easier.

The type inference in C++ can indeed lead to this kind of traps. Need to be careful as usual.

Interesting work from Apple and Google to have better hardening in libc++. It's nice to see it ripples through the upcoming C++26 standard as well.

Another nice use of the upcoming C++ reflection feature.

Indeed, the C++ syntax for closure captures is way superior to the Rust one. Interesting musing on a potential path forward for Rust.

Maybe we have a path forward for performance stackful coroutine? More pieces need to fall in place but this looks promising.