Anyway, it turns out Brad Fitzpatrick (let’s call him fitzy) is kind of a programming prodigy. He got his start reading computer manuals when he was five, and started programming in BASIC when he was six. He recounted one anecdote wherein instead of doing his long division homework in elementary school, he wrote a computer program that worked it all out for him, including the intermediary steps, which he printed out, and then copied it in pencil to his homework sheet. That’s a high level of nerdity at a very young age. That’s like, a Jason Fox-level nerdity usually reserved for fictional situations involving an iguana and some kind of sibling blackmail.

fitzy is young, born in 1980, which means he doesn’t know Lisp. Which means he’s awesome. His primary hackery is done in Perl and C, but now that he works for Google, it’s Python, Java and C++, which Google apparently regards as the holy trinity of programming languages. He’s also the author of memcached, which is a huge surprise to me. If you had asked me who wrote memcached and who wrote LiveJournal, I would have said “a genius and an idiot”. Rarely do those two coincide.

Peter Seibel is revealing himself as less of the stereotypical brown-nosing, sycophant-ish interviewer as he calls fitzy out on some contradictions. fitzy is whining about the inflexibility of Java programmers (don’t even get me started about them) and their refusal to use the JNI for interoperability, and then later talks about how Google’s inflexibility with multi-language support is actually good.

The problem with that is that you end up writing everything twice, once for C++ and Python and all the other languages, and then once for Java. So if they could come up with a good embedding story or get over this fear of JNI, then I wouldn’t mind it.

Later, when fitzy is singing the praises of the Google App Engine, Seibel calls him out.

[fitzy]: The fact that App Engine gives you one button, “Put this on the Web,” and you write in one language, arguably a pretty easy-to-learn one, Python, is perfect. It’s a great into to programming – there are so many layers and layers of bullshit that it gets rid of.

[Seibel]: How does that fit with your dismay at the Java guys who tell you “Oh, Java takes care of that for you.” Isn’t that the same? “Well, App Engine will take care of that for you.”

[fitzy]: I don’t know. Maybe it’s because I know what’s going on.

Radness.

There’s also some good insight into the software development lifecycle at Google, including coding guidelines, standards, release schedules and ownership. Apparently it’s pretty wide open: the entire codebase is totally open to everyone, and anyone can submit patches or commit as long as they get it code reviewed and get the approval of the directory owner. That openness is probably why Google has been so successful.

I’m sincerely hoping one of the interviews in this book will reveal someone who’s not a bigot toward other languages other than the ones they are experts in. fitzy did not deliver on that.

One interesting thing about fitzy is that he uses the same question in every interview: implement arbitrary precision multiplication. Apparently that was a question on his AP CS test in high school. Let’s see what I can do:

function multiply($string1, $string2) {
	$len1 = strlen($string1);
	$len2 = strlen($string2);

	$result = array_fill(0, $len1 + $len2, 0);
	for ($i = $len1 - 1; $i >= 0; $i--) {
		$val1 = intval($string1[$i]);

		for ($j = $len2 - 1; $j >= 0; $j--) {
			$val2 = intval($string2[$j]);
			$value = $val1 * $val2;
			$index = ($len1 + $len2 - 1) - ($len1 - $i - 1) - ($len2 - $j - 1);
			addWithCarry($result, $index, $value);
		}
	}

	return ltrim(implode('', $result), '0');
}

function addWithCarry(array &$result, $index, $value) {
	if ($result[$index] + $value >= 10) {
		$temp = $result[$index] + $value;
		$result[$index] = $temp % 10;
		addWithCarry($result, $index - 1, floor($temp / 10));
	} else {
		$result[$index] += $value;
	}
}

It was an interesting interview. Joel Spolsky referred to him as the penultimate Duct Tape Programmer, whatever that means. I assume he meant to type “hacker” but misspelled it. It’s a common typo; the keys are like right next to each other.

Anyway, it’s clear from the beginning that jwz (as all of his friends call him) is a Lisp geek. So I pretty much hated him right away. Nothing annoys me more than people who think every language except the one they know really well is total crap. ALL languages suck. Except C#, which is God’s gift to man. But that doesn’t count because everybody already knows that.

The first couple pages are dedicated to the glorification of Lisp, and Lucid Lisp, and Common Lisp, and other things that only people over 50 know about, and the damnation to eternal Hell of Perl and C++ templates. I took a Common Lisp class in college and I came away with two things:

1. Recursion is awesome
2. I never want to touch Lisp again

There were other corollary (koar-uh-larry, dammit; I was a math major) things I learned, such as “Lisp sucks” and “Why are there so many parentheses” and “Why can’t any Lisp programmer format their code in a readable fashion.” All in all, it was a decidedly academic experience, which is where Lisp should have stayed: in academia. But I digress.

j-dub talked about his early days of hacking telephones, hating school, and generally being an all around Lisp pimp (Pisp?) by the time he was 15. His monologue on his days at Netscape were more interesting (unless you’re that other guy who knows Lisp) than his descriptions of his oddly creepy love affair with Emacs, or his equally creepy hatred of GDB. If I knew how to debug C code by looking at opcodes, memory addresses and registers, then that would have been a good read, but since I was born after the death of Hitler (Godwin’s law) I didn’t really understand any of it.

The more interesting parts were how he rewrote Richard Stallman’s C compiler, and him making fun of how everybody else’s code sucks. Because nothing is as much fun to a programmer as mocking and degrading the hard work of another programmer. That’s not a joke. I currently pay my rent by doing that.

The one thing which I truly enjoyed from the chapter was his description of the Gang of Four’s Design Patterns. And I quote:

Then there was another book that everybody thought was the greatest thing ever in that same period – Design Patterns – which I just thought was crap. It was just like, programming via cut and paste. Rather than thinking through your task you looked through the recipe book and found something that maybe, kind, sorta felt like it, and then just aped it.

…snip…

Then in meetings they’d be tossing around all this terminology they got out of that book. Like, the inverse, reverse, double-back-flip pattern – whatever. Oh, you mean a loop? OK.

That reminds of a story of how one of my coworkers was showing me a .NET IoC container called Unity. It’s nice, and gives you exactly what you’d want out of an IoC container for the most part. Like every other framework ever, it’s inherently confusing with plenty of misleading indirection. But it’s another thing to put on your resume.

Anyway, he was explaining how he was using the Unit of Work principle here, and… “Wait, what’s unit of work?” I asked. He replied, “Well, it’s basically a transaction, that, uh… enables you to safely… execute… some piece of code… and… uh…” I cut him off after 10 seconds of niners and said, “You had me at ‘transaction’”.