Indeed there is a tension between both approaches in package ecosystems.

This is a worthy questioning... We try to reuse, but maybe we do it too much? For sure some ecosystems quickly lead to hundreds of dependencies even for small features.

Nice musing on how a type system can be a way to tame complexity or at least isolate it explicitly in one place.

It becomes clear that there are more and more reasons to move back to simpler times regarding the handling of web frontends.

The Web standards are indeed too complex. That severely limits the possibility of browser engine incumbents. I agree there's a deeper lesson here about the scale of technologies.

Or why you shouldn't insert an abstraction just for the sake of it. Also clearly not all abstractions are created equal.

This highlights quite well the limits of the models used in LLMs.

There is some good advice in this piece. If you want to maintain something for a long time, some aspects need to be thought out from the beginning.

It tries hard at not being a "get off my lawn" post. It clearly points some kind of disconnects though. They're real. I guess it's to be expected with the breadth of our industry. There are so many abstractions piled onto each other that it's difficult to explore them all.

Another rebuttal of Clean Code. Most of it makes sense if not overdone. There's the usual confusion around the "unit tests" term though, so take that section with a pinch of salt.

Interesting reasoning about what is hard in systems with concurrency. It's definitely about the state space of the system and the structure of that space.

Good musing about complexity. Very often we need to move it around, the important question is where should it appear. For sure you don't want it scattered everywhere.

Definitely a good post. No you don't have to go all in with cloud providers and signing with your blood. It's often much more expensive for little gain but much more complexity and vendor lock in.

Good illustration of how the C++ language complexity is out of hands.

A nice subset of HTML to ensure better accessibility and reduced complexity.

It's sometimes extremely difficult to get to the original source of a scientific claim. Our corpus of science is so large and complex now that finding where a claim comes from can be a daunting task.

I very much agree with this. The relationship between developers and their frameworks is rarely healthy. I think the author misses an important advice though: read the code of your frameworks. When stuck invest sometime stepping into the frameworks with the debugger. Developers too often treat those as a black box.

Another good set of advices. They're not all technical which is to be expected.

Definitely this. Our cognitive capacity is limited, we'd better not deplete it due to complexity before we even reach the core of the problem at hand.

I tend to side on the "boring tech" side, but indeed this is a good reminder that what we want is finding the right balance.