Beating the Averages

Here is my two cents.

First, Paul Graham is in my opinion not the best writer for non-technical views on lisp. Richard Gabriel is. Here is a link to his writings.

Second, this essay doesn't serve to give a careful analysis of lisp in a technical way, and to me comes of as propaganda. Its content is a priori truths and language elitism (the Blub paradox). How do you determine which language is faster to prototype in? Has this ever been measured? Can it even be measured by itself, or is it the result of the intersection of lots of things in a programming language?

You will also note that it's Lisp mentioned here, not Common Lisp. Anytime this is done, you need be on guard. Usually this refers to some ideal that exists only in someone's head, and the embodiment of this ideal will usually deviate in some subtle, but for the holder of the ideal, crucially important way. To see this in action, hop on the comp.lang.lisp archives and search for Scheme vs. Common Lisp.

For Paul Graham, it doesn't appear that Common Lisp meets his Lisp ideal. You can read here and here.

What bothers me about this and other Lisp writings from Paul Graham is not their content, but what these articles do to other people, especially the HN crowd (I don't like the community around HN. It seems to be filled with techno elitist libertarian solipsists whose greatest joy is rewriting web apps in the latest $LANG_OF_THE_MONTH and $JS_FRAMEWORK_OF_THE_MONTH while chugging Soylent and listening to Apple keynotes). There are probably a thousand blogs that have some post pontificating on Lisp, with titles like "Why $LANG is an acceptable Lisp", like they're trying to lay claim to the "secret powers" that "Lisp" supposedly gives you as alluded to in this essay. What actually constitutes "Lisp" or the criteria for being a "Lisp" is usually not specified and left as an exercise for people to project there own "Lisp" ideal onto whatever language they fancy.

Lisp, like ALGOL, does not exist. It is a term useful for classification. Ruby, Python, C, C++, Java, Perl, etc. are ALGOLs. Common Lisp, ISLISP, EuLisp, Le Lisp, Racket, Clojure, Guile, Gambit, Shen, etc. are Lisps. No one says "Python isn't an acceptable ALGOL" or anything like this because no one sees any of the ALGOLs in there commonality. They see each ALGOL as discrete; each on a union of semantic features, with the "real" difference being how you syntactically access those features. Aside from people who program in Lisps, few see them as discrete. They see parens and start projecting.

This article and others did have an effect on me when I was younger, and did impart a curiosity about Lisps which eventually turned into a curiosity about languages in general. However, I think Common Lisp and various other Lisps stand very tall on their technical merits and their communities now more than ever. The majority of posts on /r/lisp focus on this and the contributions of people to their favorite Lisps and their communities. I'd like to see future potential lispers becoming inspired to use a Lisp based on technical merits, history, and the communities around them, rather than becoming interested in using it to justify some technology fueled superiority complex. The reality is better than the propaganda. I think the Graham essays can be safely left to the people on HN to fawn over.

/r/lisp Thread Link -