List of strategies to keep in mind when debugging.

Since we often still see in the wild code with deep nesting due to edge cases handling, it looks like this advice is still very relevant.

This is definitely a big release! Lots of changes and improvements in this language.

A bit of a rambling, there's something interesting in it though. Splitting small functions early will do more harm than good if they're not reused. Don't assume they automatically make things easier to read.

Good list of things to keep in mind when thinking about performances. Of course, always measure using a profiler when you want to be really sure.

The claim is huge. The story doesn't quite say how much is really about Elixir and how much from the revised architecture. That being said, going for something like Elixir has definitely an impact on the architecture... could it be that it pushes for better patterns?

Nice overview of the good uses and wrong uses for classes. We're far from the abuses of the early times now.

Another partial quote which led to misunderstanding. One should indeed think about performances early on.

This is clearly getting more mature. Even the list of issues presented here actually makes me want to try it more as to evaluate the exact impacts.

To take with a pinch of salt, it conflates a few things in my opinion. Still it's a good reminder that eliminating complexity shouldn't be a goal. Managing said complexity and avoiding the undue one, this is what matters.

Very good points. Picking a particular language is likely not the right approach. Trying to apply the main principles of functional programming on the other hand is more likely to bear fruits.

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.