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

I generally don't like this kind of articles. It's often snake oil salesmen writing this... Now this one has good advice instead. Of course it doesn't mention how much luck has to be involved as well.

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.

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.

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

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.

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

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

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