Illustrated with Rust in this case, but definitely one of the big advantages of having type systems. Adding constraints (even runtime ones) to your types make it harder for bugs to hide.

Definitely a clever combination of two Python constructs.

Interesting look at module systems and what they entail. It's funny to see that most languages do things slightly differently in this area.

Nice summary of everything you can do with operators overload in Python.

Wise words. This is overall a good approach to add new components and behaviors to a system.

Interesting update. Looks like Go is making progress at its own pace and tries to stay small.

I mostly agree with this. I'd just complete it a bit: it's probably a good idea to have at least one language where you went really deep in (emphasis on at least). A kind of strategy to aim at "T shaped skills" (or better "paint drip shaped skills").

Interesting optimization on this somewhat common data structure.

This is a neat example of what programming languages could check at compile time. This clearly brings way more safety when you get such contract validation at build time.

I always felt uneasy around this "law" as well. It's a good deconstruction of it and proposes proper alternatives. It's all about dependencies really.

Interesting to see what gets confirmed (slow compiler, nice compiler error messages, code quality) or debunked (steep learning curve, interoperability).

Nice set of advises when dealing with concurrency. Don't fall into some of the anti-patterns which are pointed out.

Interesting way to look at our profession... I wonder if this is the core reason of why we have a hard time to turn into a proper engineering discipline, is it even possible at all then?

Interesting deep dive in Rust and C++23 string formatting features. This shows the differences quite well. It also does a good job at highlighting the pros and cons for each approach.

Neat little resource. We indeed should pay more attention to complexity across our industry.

Interesting point of view on why static typing seems to make a come back right now and why it's likely to continue. I think a few of the arguments in here are wrongly framed (like some of the benefits of using an interpreter rather than a compiler are attributed to dynamic typing while it's rather orthogonal) but a large part of the analysis seems valid to me.

We went from quality to quantity it seems. We also have whole swats of developers who are just consuming content without critical thinking and it's a problem. The conclusion says it all: "Don’t consume. Create. Ask questions. Stay curious."

Interesting parallel taken with IKEA. Some of their principles translate to nice traits for software as well.

Funny list of anti-patterns. Not all of it is C++ specific in there, but some are good reminders of the hidden traps in the language.

Nice list of patterns leveraging the Python type hints for richer and safer interfaces.