Review: Zero Bugs and Program Faster, by Kate Thompson

[Russ Allbery]

Zero Bugs and Program Faster
by Kate Thompson

Publisher: Kate Thompson
Copyright: 2015
Printing:  December 2016
ISBN:      0-9961933-0-8
Format:    Trade paperback
Pages:     169

Zero Bugs and Program Faster is another book I read for the engineering
book club at work. Unlike a lot of the previous entries, I'd never
heard about it before getting it for the book club and had no idea what
to expect. What I got was a lavishly-illustrated book full of quirky
stories and unusual turns of presentation on the general subject of
avoiding bugs in code. Unfortunately, it's not a very deep examination
of the topic. All that an experienced programmer is likely to get out
of this book is the creative storytelling and the occasionally
memorable illustration.

I knew that this may not be a book aimed at me when I read the first
paragraph:

  If two books in a bookstore teach the same thing, I take the shorter
  one. Why waste time reading a 500-page book if I can learn the same
  in 100 pages? In this book, I kept things clear and brief, so you
  can ingest the information quickly.

It's a nice thought, but there are usually reasons why the 500-page
book has 400 more pages, and those are the things I was missing here.
Thompson skims over the top of every topic. There's a bit here on
compiler warnings, a bit on testing, a bit on pair programming, and a
bit on code review, but they're all in extremely short chapters,
usually with some space taken up with an unusual twist of framing. This
doesn't leave time to dive deep into any topic. You won't be bored by
this book, but most of what you'll earn is "this concept exists." And
if you've been programming for a while, you probably know that already.

I learned during the work discussion that this was originally a blog
and the chapters are repurposed from blog posts. I probably should have
guessed at that, since that's exactly what the book feels like. It's a
rare chapter that's longer than a couple of pages, including the room
for the illustrations.

The illustrations, I must say, are the best part of the book. They're
are a ton of them, sometimes just serving the purpose of stock
photography to illustrate a point (usually with a slightly witty
caption), sometimes a line drawing to illustrate some point about code,
sometimes an illustrated mnemonic for the point of that chapter. The
book isn't available in a Kindle edition precisely because including
the illustrations properly is difficult to do (per its Amazon page).

As short as this book is, only about two-thirds of it is chapters about
programming. The rest is code examples (not that the chapters
themselves were light on code examples). Thompson introduces these
with:

  One of the best ways to improve your programming is to look at
  examples of code written by others. On the next pages you will find
  some code I like. You don't need to read all of it: take the parts
  you like, and skip the parts you don't. I like it all.

I agree with this sentiment: reading other people's code is quite
valuable. But it's also very easy to do, given a world full of free
software and GitHub repositories. When reading a book, I'm looking for
additional insight from the author. If the code examples are beautiful
enough to warrant printing here, there presumably is some reason why.
But Thompson rarely does more than hint at the reason for inclusion.
There is some commentary on the code examples, but it's mostly just a
discussion of their origin. I wanted to know why Thompson found each
piece of code beautiful, as difficult as that may be to describe.
Without that commentary, it's just an eclectic collection of code
fragments, some from real systems and some from various bits of stunt
programming (obfuscation contests, joke languages, and the like).

The work book club discussion showed that I wasn't the only person
disappointed by this book, but some people did like it for its unique
voice. I don't recommend it, but if it sounds at all interesting, you
may want to look over the corresponding web site to get a feel for the
style and see if this is something you might enjoy more than I did.

Rating: 5 out of 10

Reviewed: 2017-04-25

-- 
Russ Allbery (eagle at eyrie.org)              <http://www.eyrie.org/~eagle/>