Well, this is a bit obscure but we have to know it's there somehow. Better not rely on it too much though.

There are nice mechanism in the Java type system nowadays to no rely on Optional all the time. This is a good reminder of the main alternative.

Interesting musing about a language size and how it evolves over time. There's clearly tension between making it too big and keeping it relevant to modern uses.

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.