The Lie of Easy Abstraction

 

We live in a time where programming seems easier than ever. Just a few lines, the right library, a modern framework, and... it works. But does it really? And most importantly: do we understand why it works?

The Illusion of Simplicity

Modern tools promise to "abstract away the complexity." They say you don't need to know about registers, bits, or silicon. Just "call a function." And at first, it feels easy.

But that simplicity is an illusion.

Behind those few lines are dozens or hundreds of layers of code you don't know, don't control, and often even the authors don't fully understand.

Abstract Code Is Fragile

When everything works, abstracted code feels like magic. When something breaks, it's a nightmare:

• Errors are hard to isolate

• Stack traces are unreadable

• Functions behave in unexpected ways

• Bugs come from external libraries you never touched

Abstraction promises speed, but often hides the truth. And hiding the truth in programming is dangerous.

The Hidden Reality

Much code is closed, obfuscated, and hidden — not to protect its value, but to hide its fragility. Keeping the code private avoids exposing:

• Bugs

• Messy structures

• Chaotic architectures

The result? Code that works, but no one understands anymore.

The Value of Transparency

Programming without abstractions isn't punishment. It's a gift.

Using instructions like sbi 5,5 shows you what really happens:

• You're writing a 1 into a bit of a register.

• That register controls a physical pin.

• The pin turns on an LED.

You don't even need to know that 5 means PORTB. Just know it's one of many 8-bit registers, and you're sending current to bit 5. That's it.

https://costycnc.github.io/avr-compiler-js/

What About Android, iPhone, and Windows?

Yes — even modern operating systems live on heavy abstraction. Here's how:

Android & iOS

• Use powerful SDKs and libraries that seem easy.

• But underneath are layers of runtime, firmware, drivers, HAL, and more.

• Even turning on an external LED is difficult or impossible without rooting or complex native code.

Windows

• Offers convenient development (.NET, GUI tools).

• But anything low-level (drivers, hardware access) is opaque, hard, or limited to experts.

Direct Comparison:

System	Heavy Abstraction?	Register/Silicon Access?	Easy to Understand Internals?
Android	✅ Yes	❌ No	❌ No
iOS	✅ Yes	❌ No	❌ No
Windows	✅ Yes	❌ No	❌ No

These systems are built to be used through libraries. If something breaks, you can't "see inside."

Conclusion

Abstraction is useful, but it must never replace understanding.

If you first learn how things truly work, you can use abstractions wisely. But if you start only with shortcuts, you're building on sand.

This blog exists to remind us of that — and to prove that even ordinary people, not just engineers, can understand. You just need the right explanation and the courage to start from bits.