How many typos are there in this post? I’m betting zero, but I’m not sure. Sometimes I’ll be browsing through old ones and come across some minor error–an of for if fat-fingering, writing an for and because that’s how I pronounce it, or the cut-and-paste detritus of syntactic futzing. None is particularly disfiguring, but they still amaze me just by being there because these posts are short and I reread them carefully. It’s almost as if after you have finished and forgotten a piece of writing it will begin to spontaneously sprout typos like mold growing in the dark.
This isn’t the case of course. It is a false attribution of animacy to typos as a way of denying my capacity for error. A better, humbler explanation is that the probability of making an error in a given piece of writing is never zero. It may go up with the length of the piece and down with the care with which it is copyedited, but it never vanishes. Murphy’s Law states: it’s always something. Maybe it’s illuminating to put special emphasis on the always. The endless typo phenomenon isn’t confined to writing. In fact there is a whole class of human endeavor whose error rate decreases asymptotically. The class isn’t unbounded–either your socks match or they don’t–but it’s surprisingly broad.
Now some care must be taken for this not to become a vacuous truism along the lines of “Nothing’s perfect”. Can a carpenter ever sand a board until it is perfectly smooth? Sure it feels smooth to the touch, but if you examine the surface under a microscope there’ll be all these divots…More generally, if your notion of error is continuous there will trivially be an infinite number of ways to get something wrong. In practice, however, nobody puts a board under a microscope. At some point it becomes smooth enough. So let’s limit ourselves to discrete error spaces. Let’s even more restrictively consider sequences of error where we find each new one equally surprising. The amazing thing is that even then the gremlins will find a way in.
Computer programs manifest their flaws in a similar way. (I maintain that the connections between generating prose and generating code run deeper than is often suspected, but that’s a story for another time.) There’s always another bug. The craft of software engineering lies not in getting your product perfect but in pushing its imperfections down into the noise. But even if you know this, the tenacity of error can still amaze you. After awhile you can’t believe that a given program could still have flaws. It seems like there should be an upper limit. (There is with prose, after all. Imagine a passage that was nothing but typos.) But hang around long enough and there’ll always be another bug. In the course of its proper functioning, software seems appropriately mechanical, but in the variety of its failure, it is wild, organic, and endlessly creative.