A good point... everybody should know at this point that delegation should be favor. So why do we keep turning to inheritance even in cases we shouldn't? Convenience and writing less code mainly. Unfortunately that leads to bugs more often than not.

Neat way to think about array indices, if it was widespread it would simplify a few things in documentations I think.

Development is and has to be a team sport indeed.

That's an interesting perspective. Rust definitely gets in the way of iterating quickly indeed which might be a problem to test ideas. Introducing it gradually later is thus a better path. That being said it doesn't always have a great story for mixing with other languages, there are a few tools to help, but nothing I've seen really used in the wild so far (this will probably come though).

Alright, that's an impressive set of tools they created to build their games. Lots of efforts went into this, very inspiring.

In praise of the little ideas and the small achievements. They are often overlooked but definitely needed.

Or why they are definitely not a magic tool for programming. Far from it. This might help developers a tiny bit, at the expense of killing the learning of students falling for it and the creation of a massive amount of low quality content.

To me that looks like a fine advice even outside of C++. If conditions get at least a bit complex moving them out of the if to assign them to const booleans is always a good idea.

It's good to also see articles which point out the problems with Rust. Overall I find it an interesting language but people tend to oversell it too much. This is a nice reminder it already carries complexity issues.

Excellent conclusion to the recent turmoil around undefined behaviors. The way they are currently used as definitely a problem, they shouldn't be ignored in your code (although that's admittedly not that easy). There's hopefully a path forward.

Nice primer on std::variant. Covers all the bases of how to use it properly.

Problems with integers now. Kind of better known usually, still to keep in mind as well.

Excellent piece about technical debt. The approach proposed is definitely the good one, it's the only thing which I know to work to keep technical debt at bay.

Nice set of problems encountered when using floating point numbers. Definitely to keep in mind.

Nice resource to get started with Prolog.

Since I'm also a bit of a nerd of nice programming language features, that's an interesting list (mostly) coming from less known languages. Some of that syntactic sugar would be welcome in more main stream languages I think.

Like it or not, this is definitely filling a very unique niche. It's a very good fit for system software where safety is important and available time limited. There is no better option for now.

Good points, this shows quite effectively the problem with blindly following rules without keeping in mind the reasoning behind them.

Good piece. I like how it frames the debate, asking the right questions on where might be the assumptions on how testing is done.

Excellent piece about naming things in code. The conclusion is perfect of course: it's hard but it pays off.