Blub Crisis

As long as our hy­po­thet­ical Blub pro­grammer is looking down the power con­tinuum, he knows he’s looking down. Lan­guages less powerful than Blub are ob­vi­ously less power­ful, be­cause they’re missing some fea­ture he’s used to. But when our hy­po­thet­ical Blub pro­grammer looks in the other dir­ec­tion, up the power con­tinuum, he doesn’t realize he’s looking up. What he sees are merely weird lan­guages. He prob­ably con­siders them about equi­valent in power to Blub, but with all this other hairy stuff thrown in as well. Blub is good enough for him, be­cause he thinks in Blub.

When we switch to the point of view of a pro­grammer using any of the lan­guages higher up the power con­tinuum, however, we find that he in turn looks down upon Blub. How can you get any­thing done in Blub? It doesn’t even have y.

By in­duc­tion, the only pro­gram­mers in a po­s­i­tion to see all the dif­fer­ences in power between the various lan­guages are those who un­der­stand the most powerful one. (This is prob­ably what Eric Ray­mond meant about Lisp making you a better pro­gram­mer.) You can’t trust the opin­ions of the oth­ers, be­cause of the Blub para­dox: they’re sat­is­fied with whatever lan­guage they happen to use, be­cause it dic­tates the way they think about pro­grams.

I know this from my own ex­per­i­ence, as a high school kid writing pro­grams in Ba­sic. That lan­guage didn’t even sup­port re­cur­sion. It’s hard to ima­gine writing pro­grams without using re­cur­sion, but I didn’t miss it at the time. I thought in Ba­sic. And I was a whiz at it. Master of all I sur­veyed.

The Blub Para­dox, Beating the Av­er­ages, Paul Graham

I have real­ised in re­cent con­ver­sa­tions about pro­gram­ming lan­guages, and in re­flec­tion of my very neg­ative and kind of ar­rogant blog post about Go, that I have be­come trapped by the Blub Para­dox. I have be­come dis­missive of non-Haskell lan­guages. I think in Haskell. Lan­guages less powerful than Haskell are ob­vi­ously too lim­ited to get any real work done in, and lan­guages with more ad­vanced fea­tures than Haskell (like de­pendent types) are really just weird and not ac­tu­ally solving a problem I would ever face.

The ar­rog­ance! Such a know-it-all!

I have de­cided to call such a real­isa­tion a “Blub Crisis”. Haskell is my Blub. The only solu­tion is to be­come pro­fi­cient—ac­tu­ally pro­fi­cient—in a dif­ferent lan­guage, and once again learn a new way of think­ing.

Target Audience
Not you