It Takes a Nation of Millions to Lift Us Up

Today I was explaining to my son, the Highlander, how computer programming works. I started with my typical premise, which is that computers are dumb.

And computers are dumb. I mean, incredibly dumb. Computers are so dumb, I explained, that you literally have to instruct them about things like, take the contents of this register and compare them with the contents of some other register and then store the result in some other register.

And actually, I went on, computers are even dumber than that, because really a computer is just a collection of millions of little switches, and every single time a switch changes position it’s because the computer was programmed to make that specific change in response to some specific input.

But I don’t do either of those kinds of programming. I don’t write firmware, and I don’t write in assembly. I don’t even write in a language that compiles to assembly.

I write almost exclusively for virtual machines, I explained, a whole computer written in software that sits on top of other computers so that the same program can run on different kinds of computers, even though the computers need different lower level instructions.

“Oh,” he said. “That sounds easier.”

It is.

Every time I write software, I’m indirectly leveraging the work of tens of thousands of people that took place over millennia, from Aristotle to Turing. I’m directly leveraging work done by thousands of people who are still alive, and wrote a lot of software that I can use to write even more software. I am, whether I like it or not, collaborating with others every time I write software, because their ideas, languages, and libraries inform my solutions.

This is not a terribly deep thought, I guess. It’s sort of obvious. Still, it sometimes seems to me that this idea gets lost. People think of programmers as being in some way isolated and independent, some programmers see themselves as isolated and independent. But we’re not, we’re deeply dependent on the programmers around us, to enable us by writing languages and libraries, to answer our stack overflow questions, to develop clever algorithms that we can leverage.

If no one had ever figured out how to write a simple key value store, could you come up with an efficient implementation? Because I couldn’t. I can use them, but build one? From scratch? Without even the math done already?

Nope. Not happening.

Programming is collaborative in a very deep way, more so that almost any other field. Sure, if someone builds a bridge, they are leveraging the work of centuries as well. The nature of programming, however, is that much of that work is literally and directly part of the final product. The library I include is literally part of my code in the end. I’m not merely using ideas and knowledge, I’m using the thing itself. If software were a bridge, then the contractors would make a phone call and the piers would just show up, installed and ready for customization. Free. Instantly.

And of course, the person making the phone call would need almost zero knowledge about bridge piers.

At a recent ruby meetup I attended, one of the speakers was introducing rails generators. Not generators like, rails g scaffolding, generators like, “make me a rails project with devise and bootstrap installed and configured”.

Instant, free bridge piers.

We stand on the shoulders of others. Not on the shoulders of a few giants, but on the shoulders of a multitude of coders not much different than ourselves, who solved a tough problem and shared that solution with us so that we would never have to solve it again. In some ways, coders have more cause to feel humility and gratitude than any other single profession that the world has ever known.