honest.knave

… or, Stop being so myopic, and I’ll stop calling you code monkeys.

First, a quote from the famously eloquent Donald Rumsfeld:

“There are known knowns. These are things we know that we know. There are known unknowns. That is to say, there are things that we know we don’t know. But there are also unknown unknowns. There are things we don’t know we don’t know.”

There’s a real problem among programmers. (Well, there are several, but we’ll stick to just one for now, okay?) We know they’re cocky, but this is generally regarded as a strength. However, it plays badly with the next fact, care of Rummy: they don’t know what they don’t know. There are unknown unknowns.

The thing is, there is a sequence of events that plays out through your entire life as a coder. It goes something like this:

1. Look at the pure crap you wrote a couple years ago.
2. Realize how much you’ve improved since then.
3. Think, “Wow, I’m a top notch programmer now.”
4. In a couple years, repeat step 1.

So, a year after you learned C++ in college, you thought you were on top of your game. You knew how to manage your memory (and dammit, you liked it that way), you created pure virtual interfaces, you’ve internalized Design Patterns and invented a couple of your own. And, because you’re cocky, you figure those Java guys are just dumb because they need a crutch like garbage collection.

Fortunately, programmers have one more quality beyond hubris and laziness: they also get bored easily. After C++ starts to get pretty mundane, you think maybe I’ll broaden my horizons and write a Java program. So you learn the basics, and you decide to write a small utility you’ve been wanting for a while now. You figure it’s probably a two-week job, and start on it one Saturday morning. The next day, you realize, “Wait… I’m done?”

Suddenly, you notice the vast set of standard libraries. The garbage collection doesn’t seem so lame, now. The realization dawns on you, “Well, I guess most of the stuff I write isn’t really performance-critical…” After a little more research, you dig around and find out, to your surprise, that garbage collection is actually getting to be faster than hand-written memory management. And with every iteration, it gets better (some real-time JVMs have an O(1) collector). Not to mention that it’s not nearly as error-prone as managing allocation by hand.

The average person, at this point, will often admit, “Hmm, maybe I was wrong about garbage collection.” (Truthfully, some people never get this far.) But typically, this doesn’t lead to any major epiphanies, and the same person will cling to all the other ego-validating beliefs about everything else, including those pesky unknown unknowns. Something that would have taken the old, C++ aficionado weeks is accomplished in a day; this ought to blow your little mind.

Unfortunately, like that pizza and mountain dew (or is it curry and lattés these days?), clinging to old beliefs activates those pleasure centers in your brain. Eventually, you encounter one of those new, dynamic languages like Python, and snort, “Sure, it’s good for a little script here and there, but no one writes real programs in a scripting language!”

I’ll skip the part where you learn Python (or Ruby, or whatever) and start loving it. By now, it’s predictable, right? Well, here’s the real kicker: for the past half a century, while you were just pecking at the walls of your little object-oriented eggshell, the Lisp and Scheme guys have quietly been producing more and more interesting projects using weird things like closures, first class functions, and macros.

Programmers are people who specialize at seeing the general pattern behind a few concrete instances of something. Well, here’s a general pattern I think a lot of them are missing. I’m personally not very fluent in functional languages (yet), but I refuse to believe that, just because I’ve survived without many of the functional concepts so far, that they’re not awesome. At some point, a software developer needs to realize that there are bounds to one’s knowledge, and they are the bars of a cage that keep one from doing something amazing.

Hmm, what’s this Clojure thing all about…