Abstraction is fundamental to scalability

A common complaint about abstraction is “I have to jump through too many functions to understand what’s happening.” This reveals a deeper issue: distrust of interfaces. This is probably originates from experience with poor abstractions.

This mindset says: “I cannot trust function and class names. I always need to see the implementation details.”

But this approach doesn’t scale. As codebases grow, you cannot read and understand every implementation detail. If you reject abstract boundaries, you’ll spend endless time reading code instead of solving problems.

The inconsistency

Consider this: Do you read the entire STL source code before using std::vector? Do you study every line of your JSON library before parsing data?

Of course not. You trust these interfaces to work as documented. You rely on their abstractions without diving into implementation details.

The same principle applies to your own code. If third-party libraries can provide trustworthy abstractions that don’t require you to jump through implementation details, then so can you.

The difference between good and poor abstractions isn’t whether they hide details - it’s whether they hide the right details while making the important concepts clear and trustworthy.

”But I need to maintain our code, not third-party code”

This misses the point. Good abstractions reduce maintenance burden, not increase it.

When you need to fix a bug in “user validation,” you want to go directly to the validation logic - not wade through payment processing, logging, and database code that happens to be mixed in the same function.

Well-designed abstractions create clear boundaries that help you:

• Locate problems faster (the bug is in validation, not payment processing)
• Understand the scope of your changes (this only affects validation logic)
• Test changes in isolation (mock the payment system, focus on validation)

If your abstractions force you to “jump through endless functions,” that’s a sign of poor abstraction design, not a fundamental problem with abstraction itself.