The Block Builder

When I was a kid, I had a plastic box stuffed with colorful building blocks. On weekends I’d lie on the floor and piece those loose parts into something that could stand and move — a wobbly crane, a castle that toppled at a touch. No real reason for it; I just enjoyed the feeling of making something. Looking back now, I think I’ve always been that kind of person: someone who likes to build the things in their head with their own hands.

Later I got into programming and found it very much like stacking blocks. You have an idea in your head; you write lines of code and slowly turn it into something that runs on screen. The first time I printed the multiplication table in C, a few lines of code filled the screen with tidy rows of numbers — the excitement was exactly the same as finishing my first model.

But it’s also different. A block tower can fall, and you just take it apart and start over. Programming frustration is more torturing: you stare at the screen, the program is just wrong, and you don’t know why. You might spend the whole evening hunting for a misspelled variable, or realize you had a concept backwards the entire time. If you’re unlucky, you just stare blankly at the error message without even knowing what to search. That helplessness hurts much more than a toppled block tower.

But once “stuck” gives way to “it works,” the satisfaction doubles. It’s like spending an afternoon as a kid finishing a complex model and stepping back to look at it — that exact feeling. I’ve noticed that when a colleague at work mentions hitting a bug, I can’t help but wander over. Not to help, just out of curiosity: what exactly went wrong? Like crouching next to someone’s collapsed block tower as a kid, trying to figure out which step didn’t hold.

But there’s a fundamental difference between these two kinds of “building.” Blocks are limited by how many pieces you have and by the laws of physics — there’s always a ceiling on what you can build. Code has no such ceiling. It has its own constraints, of course — computing power, language features, system architecture — but those are rules, not boundaries. Within the rules you can create infinitely many things.

And what code builds isn’t just “scalable.” Once deployed to a server, it comes alive — reachable by anyone online, serving thousands of people at once. One person, one machine, and something you wrote has a chance to be used by countless others. You can photograph blocks and share them, of course, but that’s the photo spreading, not the blocks working. A running piece of code, on the other hand, is itself being touched by others, doing work for them. That sense of something alive is something the physical world can’t build.

Sometimes I think about all this and feel lucky. After growing up, I still found something as absorbing as stacking blocks in childhood. It might be just a script nobody ever sees, or just solving a very small problem. But if somewhere, someone’s life is a little easier because of your code — that feeling is much the same as lying on the floor years ago, stepping back to look at your very first block model.