Interesting historical work. It indeed went through a fast paced evolution cycle.

Martin Fowler obviously wrote a lot on the topic. This is a nice guide pointing to some of the most interesting resources on his blog around the agil topic.

Another explanation for the rule of zero in C++. We should definitely stick to it.

Always hated this notarization with a passion when I had to target Macs... One reason being that it felt fairly useless, and it's confirmed: it is pretty much useless.

An oldie now but still the best way to create a passphrase.

The definition of legacy code is ambiguous enough. We generally mean "bad code" (the wrong definition to me...). What about seeing things differently and trying to leave a great legacy behind us?

Nice list of ideas for stories estimations. I applied some of that with nice success.

This is very true. It's not like whoever produced bad code is particularly stupid, in most cases it's the context around which breaks the people.

When teams grow the usual standup/daily meeting format doesn't work anymore. What's proposed here is a nice alternative.

Lots of good advice on how to improve your logs.

A nice little primer on what systems thinking is about.

A good list of characteristics to aim for. Gives clue about the quality of your software architecture.

This is pretty much where I'm at as well regarding Firefox... Sad state of affairs.

Add to this how generative AI is used in the totally wrong context... and then I feel like I could have written this piece. I definitely agree with all that.

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.

Things went too far with the cloud monoculture. It's time to remember that it doesn't always makes sense, and in the case of databases maybe it's rarely worth it to go for fully managed options.

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

Interesting research. Can it give insights on the pervasive views of the time?

This is definitely a useful idiom. A bit like the immediately invoked lambdas in C++ but less verbose. This is nice to control intermediate variables locality and mutability like this.

A good justification of why you want to slice your stories finely. It definitely helps steering the project and reduces chances of bottlenecks.