A Bug's Life

One software error leads to insight'and madness

3 min read

Reviewed by Stephen Cass

I remember my bug. It lived in a program I was writing in college to analyze images for fractal properties, and even though 10 years have passed and I have difficulty recalling some of the names and faces of my classmates, I can still bring that bug sharply to mind and remember how, while it existed, it snarled the entire fabric of my life.

I had reckoned the software would take only a few days to write, but three weeks later I was still perched in front of my PC, biting my nails to the quick, with bags under my sleepless eyes. My program was maddeningly, incomprehensibly, refusing to work. I ran it over and over and pored through the source code, looking for the deep flaw in my logic.

So it was with a sense of wry amusement, but no surprise, that I saw that an entire novel had been written about one particularly intractable bug. If just a few weeks of fruitless bug hunting on a class project could have such an effect on me, how much more far-reaching must be the effects of a really tough bug lurking in a huge piece of commercial software?

The Bug is the work of Ellen Ullman, a rare creature indeed—a gifted writer who has also programmed in the trenches. Her novel is set in the mid-1980s, when graphical interfaces and networks were still novelties to most software professionals, let alone end users. But the habits of programmers and the challenges they face haven't changed much, and certainly bugs are no less difficult to hunt down.

Ullman's writing rings with authenticity, from the minor details of the programmers' and testers' lives to the inner workings of the bug itself, sinisterly dubbed "the Jester" by the developers.

The Jester lurks in the graphical user interface to a database, the sole potential product of a software start-up, and it has an unfortunate tendency to crash the interface while it is being demonstrated to potential customers. Because the Jester seemingly manifests only at random, it cannot be reproduced and dissected by the programmers—the first step in any normal bug hunt.

And so it falls to one prickly developer to track down the bug, assisted only by a quality assurance tester (an alter ego of Ullman herself). But as the Jester escapes trap after trap set for it, the bug begins to exert its toll upon the unfortunate programmer, who becomes more and more obsessed with what he perceives as a public indictment of his programming skills. As all his mental energies exhaust themselves on squashing the Jester, he slowly loses the ability to relate to anyone or anything around him except his workstation.

As the tension mounts, and the reader awaits the Jester's final unmasking, The Bug takes on almost the mantle of an Agatha Christie whodunit. Along the way, Ullman manages to weave in a fascinating tapestry about the nature of programming and programmers, including themes relating to linguistics, artificial life, and the echoes of their own minds that programmers leave in software.

The novel also considers what it means to create code that could be running behind the scenes for decades after everyone has forgotten the reasoning behind it—the admixture of inspiration, tradeoffs, kludges, and compromises that underlie the innocent appearance of any reasonably complex program. As our daily infrastructure increasingly relies on an accumulated base of software often written in a very different environment from today's always-on, always-connected world, this is of more than academic interest.

As a result, although Ullman's book is nominally about the year-long struggle to kill one bug in an ancient piece of software, it is a remarkably fresh look at the world we face today, with the Internet forcing a staggering number of unexpected interactions among a staggering number of programs. The Bug should be read by every software developer—and every end user who has ever experienced a software crash—if only to know that they're not alone in their endless fight against the almost-alive malignancies hiding in code.

And my bug? I finally saw it. A single missing semicolon in a line of code I must have read a dozen times before. Disbelievingly, I fixed the typo and ran the program again. A perfect image formed on the screen. The bug was dead! (My scream of triumph caused a certain amount of consternation from people within earshot.) While that was far from the last program I ever wrote, the closest I have ever come to recapturing the despair and triumph of those weeks was in reading The Bug.

This article is for IEEE members only. Join IEEE to access our full archive.

Join the world’s largest professional organization devoted to engineering and applied sciences and get access to all of Spectrum’s articles, podcasts, and special reports. Learn more →

If you're already an IEEE member, please sign in to continue reading.

Membership includes:

  • Get unlimited access to IEEE Spectrum content
  • Follow your favorite topics to create a personalized feed of IEEE Spectrum content
  • Save Spectrum articles to read later
  • Network with other technology professionals
  • Establish a professional profile
  • Create a group to share and collaborate on projects
  • Discover IEEE events and activities
  • Join and participate in discussions