I’ve spent 22 years in tech, and the complexity involved in building software for a modern computer from the bottom up is still truly, mind-blowingly, incomprehensibly, staggering to me.
Abstractions atop abstractions, dependencies upon dependencies at build and run time, archeological layers of backward compatibility and reasons-for-being, evidence of design trends that came and went, vestigial features that were never fully fleshed out, unique, bespoke solutions and optimizations, workarounds for hardware, unexpected behavior that fossilized into an unspoken part of the interface—and all under active development and maintenance by legions of humans, ever-changing.
It’s a towering testimony to the ability of humans to tame (or at least safely ignore) complexity to a level that fits within their working memory; to come up with abstractions and metrics that define a problem space that can be managed by a small team.
But once in a while, you look behind the thin veil and see the billions of tiny gears meshing to create a working machine, and wonder how it all works; and yet, it mostly does. No one can comprehend all the complexity, yet somehow, everything comes together as a useful tool.
I’m not sure whether this is a reason to celebrate or mourn, but it is something marvelous to behold.