WarningMight contain spoilers.

This is a feat of writing: a brilliant, insightful, and profound book that, unfortunately, only programmers and those with an interest in programming will ever appreciate (as I discovered when I recommended it to a friend with no interest in technology). Ellen Ullman transforms the prosaic workings of software and hardware into mystery, horror, suspense, and poetry. Only someone with a deep understanding of computers and programming coupled with a profound understanding of human nature, who had lived the Silicon Valley life, could even have conceived of this book, let alone created such a work of art.

It’s hard to believe how one man’s entire life could be derailed by a single software bug, but the genius of the story is in how the small effects intertwine with each other and multiply. Ethan’s reactions may be disproportionate but circumstances at his office and at in his personal life are believably hellish, and he understandably feels trapped. Even though his descent into insanity is extreme, it’s all a comprehensible reaction to preceding events.

I must confess, I was taken aback to see him being described as handsome when Berta ‘looks’ at him properly in the end. Up to that point, the writing cleverly harnesses common stereotypes of software developers to create the subconscious impression that Ethan is equally unpleasant on the inside and outside—subtly reinforced by his aroused reactions to strange situations.

I’m unsure about the framing device. It’s effective at the beginning and in the middle, but it seems out of place when the story returns to the past for the final section, which I have to assume is done so it can conclude with these magnificent lines:

I like to think it would have reassured him, saved him: To know that at the heart of the problem was the ancient mystery of time. To discover that between the blinks of the machine’s shuttered eye—going on without pause or cease; simulated, imagined, but still not caught—was life.

(And speaking of Ethan’s simulation, I don’t know that it was very relevant to the story, but it made for interesting reading and provided something other than the bug to talk about. I think that justifies its inclusion.)

Paper bug reports and printed source code are something I’ve never had to wrestle in my career as a programmer. Antiquated practices make for an excellent story, but do they ever sound horrific! It saddens me to think that Ethan’s life was unraveled merely by Thorne’s code trying to index an array outside its bounds. A modern, high-level language like Rust would usually return an error with a complete stack trace, and one could then use any number of advanced tools to instantly cross-reference code right from the IDE and find all the call sites. The complete history of the file is available with a single command.

Indeed, so much of the documentation these developers maintain is redundant today: source control systems such as Git retain a complete history of the file and all the changes to it; descriptive types (if used properly) define the contract of a function, lessening the burden on the documentation; and since cross-referencing code is trivial, the workings of related functions needn’t be painstakingly detailed.

Now, software bugs haven’t gone anywhere in the interim. They can be just as evasive, maddening, and crushing as the one that Ethan encounters. After all, programming languages are necessarily imprecise translations of human thoughts into instructions for a computer, and no tool can replace those thoughts or remove the need for debugging. It’s just that the tools of software development have advanced so much since those days.

I imagine a modern version of The Bug would center around distributed systems, which are still a mystery to the human race and may exist beyond the power of human comprehension due to the scale they operate at and the infinite possibilities of their interactions. (Not that I’m suggesting such a thing is required or merited, merely contemplating the parallels.)

These lines are painfully and hilariously relatable to any experienced programmer:

‘They’re just C-code structures… Well, they should have been done in Lisp… a language that… I should have… Hell! Anyway, no.’