Published in
Digital Narrations: Fails and Errors

The Bug (Up Close and Personal)

Abstract: This essay is a subjective reflection on the nature of the computer bug. Using a statement-driven writing style that is inspired by the structure of code, I propose a new categorisation of bugs based on why and where they occur. What are the particular failures that lead to software and hardware errors? What do they tell us about the constitution of the digital world? And what can they teach us about ourselves and our relationship to machines? Drawing on my professional experience as both a software developer and an artist, I try to capture the bug not just as the technical problem it is most often described as but instead as a multi-layered phenomenon and a personal experience.

Keywords: computer bug, categorisation of bugs, programming languages, nature of code, machine thinking.


The turn of the millennium was supposed to be the beginning of the future. A shiny new world on the horizon with speaking robots and intelligent machines, with space exploration and flying cars. But as it came closer, before that future even began, its promise was tainted by the spectre of a computer bug that threatened to set the time back. That had the potential to disrupt the whole system, to bring down the machines and lead to chaos. A bug so iconic that it was named after the equally iconic year: Y2K.1 In the end, very little happened, but the phenomenon of the bug had entered the public consciousness with unprecedented force, and it has not left since.

Now, the bug is everywhere. The bug is the exploding spacecraft.2 The bug is the irresponsive phone. The bug is the loss of contact, the missing file, the interrupted connection. The bug is the payment that does not work, the broken game, the virtual pandemic.3 The bug is right there under your nose. The bug seems strange to many because it comes from the unfamiliar world of the machine, but it is now part of our daily lives.

Bad Habits

The machine is meant to help us. The machine is supposed to listen to us, to be complacent. We consider it so predictable that we are surprised when it is not. We do not think physical things or other humans will always live up to our expectations, but the machine is special. The world is complicated and hard to control, but the machine is our escape hatch. It is supposed fulfil our demands: to always be predictable. But a bug lives in the misbehaved machine.4 When it betrays our trust, that is remarkable enough to deserve its own word.

It is the reason why things go wrong and the result of things going wrong.5 The bug is always a mismatch. An expectation that is not met, a stumbling stone. The bug is recognised because it is a surprise. The bug is a rude interruption in our seamless and elegant dance with the machine.

Sooner or later, the bug will hit. It can mean that something happens—when it should not. It can mean that nothing happens—though it should. It can mean information is misplaced or lost forever, or that it exists by mistake. The bug can be funny or annoying. It can be heard or felt. It can be short lived or recurring; it can be immediately apparent or slumber for ages. The bug is seen in many forms.

Hemiptera (The Real Bug)

The real bug is a dead moth, stuck in a relay of a calculating machine and taped into a logbook from 1947. Described as the ‘first actual case of [a] bug being found,’ it is a well-known origin myth that has been shared countless times. A joke, but one that made it into the history books.6 An important message: machines are made of stuff. A machine is not just a well laid plan, but a plan that is put into the world and realised. Once the machine is turned into a physical reality, it exists in the world and thus the world can act on it. And it always does. The bug crawls into the machine and messes with it.

Figure 1. Log book with Computer Bug, 1947 National Museum of American History & Smithsonian Institution Archives, Accession Number 1994.0191.01

The real machine as a physical object is constantly influenced by the world that surrounds it. Machines will get covered in bacteria and rust, programs will get copied and transmitted with tiny errors. Lots of things influence the machine, but only a few cause bugs: things that change the logic, the instructions and the data of the machine. Because the machine contains the instructions that determine how it should behave and the machine is real, reality can change what the machine does: the roach can block the switch from switching. The vibration of a truck driving by a building can ever so slightly shift the read-head of the hard disc of the server inside, causing it to return the wrong data. Cosmic radiation can change what is stored or computed.7 The real bug is the one that physically manipulates the machine in a way that changes its state. The machine still follows its orders to the point, but they are no longer the same orders. When the instructions are messed with, the unexpected can happen.

The real bug can be made less likely by isolating the machine from the world. A data centre can be kept at a constant temperature, at a remote place, isolated from vibrations. Data can exist in multiple places; it can be verified to still be true.8 And yet, the real bug can always find a way; the real world can always come up with something that was not planned for. It is just a matter of probability. Unlike the machine, the real world never behaves.

The real bug is material. It belongs to the physical world. It cannot be eradicated, but it is rare: the machine is like an iceberg. Its tip breaches into the physical world, but its main part is ideal, it is made out of calculations and ideas. Most bugs live in that ideal sphere where the machine is a concept.

Abracadabra (The Common Bug)

Programming is about control. There is no strength needed to make a machine do what you want. Just tell it what to do. Use your language to force your will on it. A programmer’s instructions are like magic spells. Use the right ones, and they are impossible to resist. Your word is my command. Use the wrong ones, and the machine will stumble. You have encountered the common bug.

The machine is a mighty beast. But the machine is perfectly tame. If it seems not to listen, you have only yourself to blame. It always does what it is told. The beast you need to tame lives inside your head. The bug is like a sphinx. It will get you when you don’t use the right words. Machines do not like to be shouted at.9 Better speak carefully.

That is why a programmer writes things down, to make sure they are understood. They text to the computer, and the computer texts back. An endless exchange of messages with an insufferable grammar nerd. There are many mistakes a machine cannot tolerate. The tiniest typo can cause it to stumble. Can result in a bug. So, a programmer cannot be careless. No forgotten comma, no transposed letter or repeated word will be overlooked by the machine. 

Its language is unforgiving. A language where every word and every sign has exactly one meaning, needs to be used in precisely the right place and the right order. If its language is used in the wrong way, the common bug appears, and it appears frequently. But it is usually quite banal; it will be caught easily. Because the language of the machine is so explicit, the machine can point out the places where it does not understand something, where the common bug sits.

Of Milk and Eggs (The Absurd Bug)

Perfect grammar, perfect spelling, perfect syntax: the language of the machine is demanding. And yet, it has no native speakers. The programming language is not like the language of humans. There is no poetry in it, no metaphor, no ambivalence. In the language of the machine, every sign means one thing and one thing only. It does not sing, it rattles. To unlock the power of the machine, the programmer needs to change the way they speak and the way they think.10

A programmer is asked by their partner to go to the store and buy a carton of milk, and if they have eggs, get six. A programmer annoys their partner because they come back with six cartons of milk. Of course, the store had eggs, so they brought six cartons. Is a programmer a joke?11 Certainly, a programmer is still a human, not a machine, so a programmer would never do that in real life. But they had to learn to talk to machines, and making sense to a machine is different.

The machine does not know the vastness of the world, only binary logic: true or false.13 The language of the machine is a transcription of pure logic into words and symbols. 

The machine is strict and perfectly logical. It does not allow fallacies, imprecisions or shades of grey: the machine expects clarity of thought. It will not come to the programmer’s help, not guess what they mean; it will not take the context into account. And yet, it is hard to reduce the world to logic. It is hard to break down complex processes into simple steps, to spell out everything from first principles, to create algorithms. It is hard to think of every exception, every special case, hard to keep track of the thousands or tens of thousands of things that can happen at the same time.

Complex programs are pyramids. Layers upon layers of simple building blocks, of simple instructions. Systems are pyramids of pyramids, machines and submachines, with many languages and layers of translations resting on more translations.14 Welcome to the Tower of Babel. Because natural language does not follow the same standards of logic, programmers need to translate their ideas. Again and again, programmers fail at telling the machine precisely what to do. This is the realm of the absurd bug: it is not caused by an incorrect use of the machine language. It is caused by giving the machine the wrong instructions. Perfect grammar is no good for anything if is used for sentences that are absurd, that make no sense, that do not actually mean what the programmer wants to express.

Little Boxes (The Unreal Bug)

The programmer does not just need to know the language of the machine. The programmer needs to know how to tell the machine to compute. Not just to calculate numbers, but how to do certain forms of thinking. The language of the machine does not just use a different grammar and a different vocabulary. To give instructions to the machine, to make it reason about the world, the world needs to be rid of smell and feeling, of spatiality and haptics. It needs to be reduced to concepts the machine can work with. Only then can the machine be made to compute something. In the beginning, a machine knows only two things: on or off. To us they can mean one or zero. True or false. Somethings and nothings, in near endless combinations.

The memory of the machine is huge piece of blank paper in a fancy typewriter. You can put anything on it that you want. To the machine, any sign can go before or after any other. Its memory is a primordial soup of free-floating fragments. Anything can go anywhere. It is up to the programmer to structure that mess, to give those combinations meaning: to build a vocabulary, to come to an agreement, to find an understanding. Turn it into a something rigid and neat and understandable. A representation. A sound or an image, a text or a concept, something the machine can work with and the human can understand.

Find a code, encode something, define a certain pattern of ones and zeros to mean a number and another one to mean a character. Much like speaking, much like writing, a character stands for a sound and a combination of sounds for a word and a word stands for something. Define a fixed order, a structure of meaning, and suddenly there are a lot of things that can be represented with a computer.

In the beginning, the machine knows just pure data without meaning and a few instructions on what it should do to those data, to the ones and zeros in its memory. But the programmer can give that data a form, a meaning, they can make it represent something. That is when the power of the machine awakens. The machine loves to work with representations of the right kind. It can manipulate them and calculate with them. It can bend them into shape. And that is what humans want from the machine. To make the machine useful, programmers create boxes that can hold the world. Models, structures, special kinds of representation that do not just show a thing or a concept but also what can and cannot be done to it, how it interacts with other representations. Ideas that seem obvious to humans, but that the machine does not know about. And so, the programmer needs to create a format for the machine to work with. A way to cut up the world.

A calendar program knows months and years, days and dates and times, selections and displays, buttons and alarms. An online shop knows products and prices, manufacturers and clients. Things can be bought and sold, ordered and cancelled, assigned and shifted, tracked and removed. Nothing about that is specific to machines. Humans model the world so it can be dealt with, moulded, made convenient and controlled, commodified. But human boxes are soft and flexible, changed all the time to better fit their content. Categories that are based on our gut feelings, on probabilities and similarities. To make them understandable for the machine, those boxes need to be rigid and simplified. That might come at the expanse of nuance, might be paid for with a lack of realism. But that reduction is what gives the machine its power. The machine can do simple things, but it can do them fast, so it can do a lot of them.

Abstractions are tempting and convenient, but they are treacherous—dangerously close to the real deal but not quite there. Even the simplest abstractions we use can be faulty. The year does not have 365 days,15 that would be too easy. Not every address has a street name, not every human has a place of residence, not every weight is written down in the same unit. And so, programmers build complex models—make space for exceptions, try to create boxes that are closer to their reality. Try to make it so the machine behaves as expected. And yet, the machine has problems with the very basics. We think that the machine loves numbers, but it has a hard time dealing with most of them.16 Because the unexpected can happen—will happen. Because at some points our abstractions will always meet anomalies, will not fit the world, will cause unreal bugs. The unreal bug is born from the exception to the rule, the thing that does not fit the box, the odd one out. But that exception is everywhere. The unreal bug is everywhere.17

To get a working result, to not get lost in endless details, programmers need to forget that they don’t deal with reality directly but with an imperfect depiction. Reality is messy, and the box they build around it will never be a perfect fit. The unreal bug is the bug that is lurking in the programmer’s misunderstanding of the world and their misunderstanding of their programs as an accurate representation. The bug that lives in the distance between the two.

Numbers can be right. Calculations can be correct and proven. Machines can deal with abstractions without any failure. But abstractions are not the real world. Boxes might be built to fit the world very closely, but a distance will always remain. As long as the machine describes the world, the unreal bug will always find its place.

Under the Skin

There are many forms of bugs, but they all have a common habitat. The bug does not bug the machine but the human. The machine does not care if it does not understand the programmer. It does not try to fill in the gap. Programming means coming to a perfect understanding, but it is a one-way street. It is talking to a mirror. Getting to know yourself. It is not machines that are hard to understand but humans. Humans do not understand themselves. An insufferable condition, and one that makes us tolerant: we forgive and forget the wetness and the smacks our mouths make when we speak, the black holes and inconsistencies in what we say, the overlaps between and the fuzziness around and the sheer phantom-ness of words. We cannot deal with the pain of not being understood, of not getting what the others mean, of not even being certain what we ourselves really think. It is much too distressing, and so we play games of pretend. When humans communicate, they skip over gaps, jump to conclusions. Take a guess, make an assumption, and try to create a stable world.

Talking to machines means entering a different world and speaking a bizarre tongue; it is uncomfortable and insulting. If with everything you say you are taken at your word, understood the way you said it, not how you meant it, then it is up to you to make sure you say the right thing, and you must mean it, too. Programmers need to meet the expectations that they are confronted with. Because the machine has no free will. It cannot act on its own, it is subjected to the authoritarian regime of logic. And so, the human who has to talk to the machine has no freedom of expression. The program puts their understanding of the world to the test. The bug tells them that they are wrong. The bug is an insult to their intellect. A message screaming: do you not get it? Did you not pay attention? The bug is born from an incapability to see the world as it really is and it is born from an incapability to express oneself. The bug points the human straight at their misunderstandings, their weak points, their knowledge gaps, their ignorance.

The human and the world they live in create the bug: from their ambition and their inaptitude and their carelessness. From the holes in their plans. From their limitations. The human creates the machine but loses track of what it does. The human can create the bug by not paying attention or by not knowing better. By teaching other humans the wrong things. By not knowing the machine they have constructed. It is never the machine’s mistake. The machine does not know better. It does not act. It only listens. The bug is crawling on your inside. It is part of the human. They are its breeding ground, its nest, its natural habitat. The human is the source of the infestation and the one suffering from it.

Wild Dreams

To understand the bug in all its forms, we need to understand what it destroys, take a look at the delusion it rudely awakens us from. Humans love machines because they make things easy. To a machine, time does not matter. Work does not matter. Move a billion bits at the speed of light. A billion words, a billion images, a billion connections, a billion contracts, a billion dollars. Everything is so easy. The dream says: there are no borders in a digital world, no resistance that cannot be overcome at the touch of a finger. The machine offers limitless distraction, countless conveniences and effortless control. The physical world is tough, full of resistances, but the machine will help us overcome all of them.

The machine is powerful and obscure at its core. It is the ultimate stranger, familiar and yet utterly unknowable. You can learn from it, but it will hurt you, humble you. Push you off that pedestal you put yourself on because you thought you got it.

Machines help humans overcome their limits. Dreams of machines that can do anything. As we are the masters of machines, we can do whatever we can think up. If there is something we cannot do, it is because we did not have enough time—only a question of time before we can. Only a matter of a few more bugs to overcome. But the machine can never live up to our projections. It is not an ideal, not spotless, but always faulty. No machine is immune to the bug. Machines show us our limits. Machines are a dream.

Dawn and Dusk

The bug wakes us up. It is the boogie man. A scary creature, an elusive beast. The nightmarish loss of control. The bug reminds us that the machine is not perfect. The bug reminds us that we are not perfect. The bug needs to be hunted down. The bug matters because it spoils the dream. We strive for flawless victories, and the bug beats us.

The bug enters the system as an intruder. Something different, something that does not belong. A dirty, disgusting insect. Our spongy biology soiling a perfect electro-metallic machine. The bugs tears things down, drags them to the underworld. The bug is an everyday occurrence. A simple typo. A logic error. A manufacturing mistake. A misunderstanding. The bug is a banality.

The bug is the loophole in our binary categories, the gap where the sharp edge of reality cuts into our neat abstractions. The bug makes us understand that we do not understand. The bug reminds us that the shiny copy of the world we built is not real. The bug is us staring into the abyss of reason and it staring back. The bug is what makes the machine human.

Philip Ullrich

Philip Ullrich is an artist living and working in Zurich and Bern. In his work, which is partly inspired by his work as a programmer, he deals with issues of language and representation. His work has recently been exhibited at Henry Dunant Museum (Heiden), Aloïse (Basel), AEdT (Düsseldorf) and Hamlet (Zurich), as well as at various group shows. He holds a Master of Fine Arts from Zurich University of the Arts and a B.A./M.A. in Photography from Folkwang University of the Arts in Essen. Besides his personal artistic practice, he has been a part of Digital Narrations since 2016.

↑ 1

Because old computer systems often stored the year as only two digits, it was feared that the turn of the millennium would cause them to mistake the year 2000 with 1900, leading to numerous sudden problems. For a detailed description see: Feng Li, Howard Williams and Martin Bogle, ‘The “Millennium Bug”: Its origin, potential impact and possible solutions,’ in: International Journal of Information Management 19, no. 1 (1999), pp. 3-15.

↑ 2

See Jacques-Louis Lions and ESA/CES Inquiry Board, ‘Ariane 5, Flight 501 Failure Report,’ available at and Mars Climate Orbiter Mishap Investigation Board, ‘Phase I Report, November 10, 1999,’ available at

↑ 3

For example, the Corrupted Blood incident in World of Warcraft in 2005. See here for more information:

↑ 4

In line with the contemporary use of the term ‘bug,’ the term ‘machine’ in this essay refers to a programmable machine. Something like a Turing machine, a finite state machine, or a random-access stored-program machine. In layman’s terms, a ‘computer’ in whatever form (a mobile phone, a laptop, a smart fridge…). Historically, that has not always been the case. The term ‘bug’ seems to stem from Middle English bugge and used to mean ‘something terrifying.’ It lives on in the modern word bogey (as in bogeyman) and has been used since the 1870s to refer to mechanical malfunctions. An introduction to the complicated etymology of bug can be found in Anatoly Liberman, ‘Bugs: a postscript,’ OUPblog, June 3, 2015,

↑ 5

At least in everyday speech, there is hardly ever a differentiation between these different angles of looking at a bug. In technical documents, you can sometimes see them differentiated as defect, error, failure and fault. But even in a professional context, outside of highly regulated industries (e.g., aerospace), most people only ever speak of a ‘bug.’ For a detailed explanation of the technical terms, see ‘IEEE Standard Classification for Software Anomalies,’ IEEE Std 1044TM-2009 (Revision of IEEE Std 1044-1993), pp. 2-5.

↑ 6

And into the museum. The famous logbook is now in the collection of the Smithsonian National Museum of American History. The claim that this is the origin of the usage of ‘bug’ to describe a computer bug has since been refuted. To read more, see here: For more background, see Fred R. Shapiro, ‘Etymology of the Computer Bug: History and Folklore,’ American Speech 62:4 (1987): pp. 376–378.

↑ 7

For an introduction to the phenomenon, see

↑ 8

A common case of this type of error-proofing is the last digit of an IBAN. For an overview, see

↑ 9

An example of this can be seen here:

↑ 10

Opponents of the Sapir–Whorf hypothesis (which roughly states ‘our native language informs how and what we think’) might stumble here. But since a programming language is not a natural language, it functions very differently. E.g., there is no way to express abstract concepts like love. Instead, as the next sections show, the machine deals with different categories that need an adjustment away from our everyday, hand-wavy way of thinking. Whether the Sapir–Whorf hypothesis also applies to the differences between one programming language and the other is also up for discussion. While Turing complete languages can, in principle, express exactly the same things in different terms, the effort might be prohibitive. For an introduction to the topic, see

↑ 12

For a computer, even complex logic is based on the principles of binary reasoning (i.e., true or false / on or off). Machine-learning algorithms seem to change that. They use statistical, probabilistic reasoning. This leads to a very different range of errors that is beyond the scope of this essay. But even these algorithms and the data that they are trained on are initially encoded as binary values so the machine can handle them.

↑ 13

As the fundamental instructions a computer can execute are very basic, most programmers nowadays work with so called higher order languages that need to be translated into the basic instructions that make up machine code by a special program called a compiler.

↑ 14

This might seem obvious—it is why there are leap year days and leap seconds. But those exceptions can be easily forgotten. For an example of what might happen then, see Robert McMillan and Cade Metz, ‘The Inside Story of the Extra Second That Crashed the Web,’ Wired, July, 2012,

↑ 15

Because machines represent everything in a binary format—which consist of only ones and zeros—they have a hard time representing fractions and decimal numbers. An example of a bug caused by that: the calculator software shipped with Windows wrongly calculated some roots until recently. For more, see

↑ 16

As a popular saying in statistics goes: ‘All models are wrong but some are useful.’ It is usually attributed to the appropriately named George Box. For some background, see