Where's Waldo?

Programmers don’t juggle anymore.

There was a time, many moons ago, when you could pretty much assume that anyone who wrote code in a serious fashion knew how to juggle. Maybe not well, but at least well enough to keep three balls in the air for an extended period of time. Maybe even well enough to do passing patterns. You could go to a programmer’s office or desk and find a set of lacrosse balls (much better for juggling than tennis balls, until you miss).

There were other skills that were reasonably common, as well, such as lock picking. It was always nice to know that you couldn’t really be locked out of anyplace. Some programmers had real lock picking tools, while others made do with home-grown picks. It was part of what made the culture of programming somewhat unique.

I started thinking about this recently when I realized that none of the students that are around have any of these hobbies or skills. I wondered what had changed. And then I realized that it was because of the speed of the machines that we all use.

It used to be that part of programming was long periods of waiting. You put together a program of reasonable size, and it had to be compiled, which would take a while. And by a while I mean half an hour or more (I won’t bore you with the tales of waiting overnight for your deck to be run; go ask your parents). You needed something to do for the time it took the program to compile. You didn’t want to start on another program, because you wanted to be ready to fix any errors or start working on tests once the program compiled. So we did things that took enough attention to pass the time, but not so much brain power as to be actually useful. Juggling. Picking locks.

The exceptions to this were the programmers who worked in Lisp, who had instantaneous feedback from their integrated development environments. The Lisp community produced very good programmers, but they were (and this is going to get me in a lot of trouble) less interesting as people. Not only were they intolerably smug about their programming environments, but they didn’t juggle. How could they be real programmers?

Now, of course, our machines are so fast that we all use integrated programming environments that compile the whole system between our keystrokes. These interactive environments have brought all the speed and convenience of the Lisp environment to those of us who use compiled languages. The only time we wait for compiles now is when we download open-source software from someplace else and have to build the entire system from scratch (or while we wait for our IDE to initialize). But that wait isn’t long enough to do anything else other than, perhaps, read some email.

Mind you, I’m not really complaining. I wouldn’t want to go back to the days of 45 minute compiles (especially when those compiles found one typo, which got fixed in a few seconds and then required another 45 minute compile). But all this speed has made the community of programmers less interesting. No one juggles. No one picks locks. I sort of miss it.

At least the Lisp folks aren’t so smug anymore.