Around the time that the Apple Watch was released, the Wall Street Journal ran an article about the potential effect on mechanical watch sales. Within the piece lay a pretty startling quote: “When I wear a mechanical watch, I think of the precision required to make it work on such a micro scale. That’s pretty awesome as opposed to just a chip.”
Yes, mechanical watches require a great deal of craftsmanship. But a microchip is orders of magnitude more complicated than the mechanism within a mechanical watch—though this complexity is hidden. We are awash in incredibly complex technologies, and yet most of us take them for granted.
This is a problem. When some trivialize technological complexity, even inadvertently, we distance ourselves from the software and hardware that surrounds us. This ignorance—not of how things work, but even the very fact that things are far more complex than we might realize—can make us lose a sense of wonder at technology. We begin by losing an appreciation for its complexity, and end with shortchanging the very people who are constructing these technologies.
How did we get to this point? The growth in complexity has required a lot of feedback, with each step of increased complication and sophistication being built on the one that came before it. Several years ago, software engineer Jean-Baptiste Quéru explored this in a post, showing what really happens when you go to the Google home page or even just press a single key on your keyboard. And then he offers this doozy:
Today’s computers are so complex that they can only be designed and manufactured with slightly less complex computers. In turn the computers used for the design and manufacture are so complex that they themselves can only be designed and manufactured with slightly less complex computers. You’d have to go through many such loops to get back to a level that could possibly be re-built from scratch.
More generally, the current technologies of modern civilization could not be built whole cloth. As Lewis Dartnell has noted in Aeon, a spiral of ever-more sophisticated technologies have led us to where we are now. To jump to our current place, all at once, seems to be nearly impossible.
All of this is just another way of getting at one of the most fundamental ideas in computer science, and, really, in all of engineering: abstraction. Abstraction involves the hiding of unnecessary details, so that the important work can be done at the proper level. Abstraction means that programmers don’t have to contend with zeroes and ones every time they want to write an iPhone app, or that a scientist doesn’t need to write a new statistical package every time she wants to analyze some data; those details have been abstracted away. It’s essentially the only way to build sophisticated technologies. But one of its side effects is that at every stage of increased complexity, we have shielded this complexity from users, removing the ability for tinkering and grappling with the craftsmanship—which now often takes the form of mass production, rather than a single craftsman at work—of these technologies.
This shielding—while useful and powerful—has had the side effect of making it more difficult to really grasp how complex software and technology truly is. The computer scientist Edsger Dijkstra examined this in one of his talks, focusing on the “radical novelty” of programming. Dijkstra begins by recognizing that in order to build something “big and complex” we generally break it into pieces that each has some sophistication (though they can be further decomposed into smaller pieces).
But when it comes to programming, these hierarchies are far bigger than most people actually realize, and yet still need to be grappled with:
From a bit to a few hundred megabytes, from a microsecond to a half an hour of computing confronts us with [the] completely baffling ratio of 109! The programmer is in the unique position that his is the only discipline and profession in which such a gigantic ratio, which totally baffles our imagination, has to be bridged by a single technology. He has to be able to think in terms of conceptual hierarchies that are much deeper than a single mind ever needed to face before.
When we, as a society, fail to appreciate the staggering complexity of our modern technologies, we don’t just lose a sense of awe toward what is around us. We lose a sense of what we as humans can build, as well as where we might fall short. It is impressive that people can build and grapple with these astonishingly complex systems at all, something we seem to neglect when we focus on the shortcomings of a technology, rather than its successes and the effort that has gone into it. For example, autocorrect is mostly known for its failures, but in fact it’s an amazing technical feat that dramatically improves text entry speed.
But related to this is something else: Recognizing the overwhelming complexity of our technologies makes it easier to see that bugs and glitches are essentially an inevitability. When anything becomes as complicated as Dijkstra describes, unanticipated consequences will arise. Baked into a proper recognition of the phenomenal complexity around us must also then be a sense of humility—our limits in the face of the technologies we have built—something that we need to acknowledge more and more.
So how can we make sure that society gains an appreciation for such complexity? We need to more explicitly teach this idea of abstraction. It’s wonderful that people are learning how to code. There are many benefits to improving the computational thinking of our society, whether to further their job prospects, or simply to improve how people think about how software is built. Unfortunately, coding education sometimes seems to me to focus, at least initially, more on the mechanics of programming, than the larger concepts of computation: computer programming rather than computer science. Understanding an if-then statement or how to build a webpage is less important for understanding our world than the fundamental idea of abstraction, that we can bootstrap one system on top of another, while hiding the details of the ones beneath.
James Hague has written that “When it comes to writing code, the No. 1 most important skill is how to keep a tangle of features from collapsing under the weight of its own complexity.” Abstraction is a powerful means of doing so, through creating modules with interfaces that interact with each other, hiding the specifics within each of them. You can buttress one level of complexity upon the ones that have come before it, or take advantage of the specialized knowledge of someone who has built an independent component, without knowing the exact nature of what is happening within it.
We need to popularize this concept of how sophisticated technological systems are constructed. Only then will those building microchips be appreciated in the same way as those working with precise tools that allow for the placement of a miniature watch gear.
When we take microchips or really any complex technology for granted, as monolithic commodities, we lose some of the wonder we should have for them. What’s more, we lose sight of how incredible it is that we have gotten to this level of complexity at all.
A version of this piece originally appeared in Samuel Arbesman’s newsletter. Future Tense is a collaboration among Arizona State University, New America, and Slate. Future Tense explores the ways emerging technologies affect society, policy, and culture. To read more, visit the Future Tense blog and the Future Tense home page. You can also follow us on Twitter.