Mutable vs immutable is a good first approximation... but it goes further and this little article does a good job explaining why.

Developers tend to push for pair programming mostly for technical and code quality reasons. This is fine, but often the fact that it also spreads knowledge and ensures business continuity is forgotten.

This opinion piece is getting old... and yet, it doesn't feel like our professions made much progress on those questions.

Indeed, Kanban is massively misunderstood. This is unfortunate, this article does a good job explaining what this is about.

A look back at the limitations of deep learning in the context of computer vision. We're better at avoiding over fitting nowadays but the shallowness of the available data is still a problem.

Of your tests are friend with implementation classes in C++, then something is wrong. Such tight coupling between tests and implementation is not welcome.

Definitely be careful when using mocks. You can end up introducing too much coupling between your tests and the application code. Use alternative test doubles instead and reduce duplication.

A good tour of various techniques available on the web for making textured text.

This is indeed a good way to guide your debugging. Using coverage information can sometimes reduce the search space.

Nice little article. It's a good way to point out that aiming for the lowest Big-O approach is often not what you want in terms of performance. Always keep the context in mind, and in doubt measure.

Ever realized raccoons had something to do with the history of computing? And children illustrations? Work of art if you ask me... we have to get back to the time of the computer magazines.

If you wonder why more websites become confusing... It's not exactly an accident.

Indeed, more metadata in your database can be a life saver.

Nice experiment. When looking at the actual infrastructure used, the servers are indeed nicely decentralized. For the users the picture would be different though.

OK, that's a funny experiment. I don't think many people post such requests anymore.

Cool tip showing what can be done with got bare repositories.

This is a nice little experiment. Not statistically relevant (there are other papers for that), but shows in the details how introducing Rust can impact the way people work. This is interesting because it means the safety gains are not only strictly coming from the (now infamous) borrow checker. We can't rely on everyone applying all the techniques necessary but for sure they're cheaper to put in place than with C.

The concept of allocators in general and arena allocators in particular is too little know. Here is a little article which rediscover the motives behind them. It's a good introduction to the topic.

Nice table of the Linux syscalls. You can search for them based on ABI and version. It even points to their definition.

On the ever expanding domain of applicability for constexpr, more is coming to C++26. This is definitely welcome, should keep making it easier to use.