Right question but wrong answer, we fight cognitive load by learning abstractions, not avoiding it

[leric]

I agree with the article—cognitive load is what matters in software dev (and in any complex tasks). But it gets the solution wrong: we don't fight overload by avoiding abstractions; we conquer it by learning them, just like in math. Mastering concepts like calculus compresses complexity into manageable "chunks," letting you tackle huge problems without mental explosion.

Every framework and lib are some other smart developer's quirks, but if they fit, they pay off at scale, offloading grunt work so your brain focuses on the big picture, that's why some frameworks are widely used (and widely criticized). Dodging them for "boring" simplicity often creates unscalable messes where every dev reinvents the wheel.

[zakirullin]

This article is not against abstractions, it's against useless and unncecessary abstractions.

Bad abstractions:

Instantiating an object is one thing, right? So MetricsProviderFactoryFactory seems to be just fine. The names and interfaces of such classes tend to be more mentally taxing than their entire implementations, what kind of abstraction is that? Something went wrong.

Layered Architecture
...
Abstraction is supposed to hide complexity, here it just adds indirection.

So, basically they are "one class for one task, no matter the complexity of task" type of abstraction and indirection. These types of abstractions don't offload mental burden, they create it.

Good abstractions:

The interface of the UNIX I/O is very simple. It has only five basic calls
...
A modern implementation of this interface has hundreds of thousands of lines of code. Lots of complexity is hidden under the hood. Yet it is easy to use due to its simple interface.

The best components are those that provide powerful functionality yet have a simple interface.

I.e. abstraction with simple interface and complex functionality. So it is what you say - "compresses complexity into manageable chunks". Shallow modules (bad abstractions) don't compress complexity, they spread it all over the interface.