On 16 Feb 2018, at 13:42, Noel Chiappa <jnc(a)mercury.lcs.mit.edu> wrote: I think it's also important to say that claims like 'lisp is slow' are essentially meaningless. It is reasonable to say that 'this program is slow', where 'this program' refers to some definite bit of code, implicitly qualified by the machine it is running on, when the statement was made &c &c. That's clearly a thing you can go out and test. It's often safe to say that particular implementations of programming languages are slow, which means that many or most programs run using the specified implementation of the programming language are slower than they might be either using some other implementation of the same language, or written in some other programming language and run using an implementation of that. In particular I can say 'CPython is slow' for instance: this statement might be wrong, but it does at least have some content. For programming languages which only *have* one implementation or have a single dominant implementation, you can get lazy and say, for instance 'Python is slow'. What this really means is 'CPython is slow' (ie it's the same as the previous statement). It's also dangerous because it tacitly assumes that there is only one implementation of Python, which is not true (or at least has not been true in the past). But you can usually get away with this. For programming languages which have many implementations, and still more for *families* of related programming languages, each member of which may have many implementations, the statement loses all meaning. What does the statement 'Lisp is slow' *mean*? The only meaning it could really have is something like 'all implementations of Lisp that there have been are slow and all implementations *there ever will be* will also be slow'. The only way this could possibly make sense is if the person making the statement understood that some feature or features of any Lisp-family language was so hard to implement that it was really clear that no fast implementation could ever exist. I claim (without evidence) that Lisp-family languages, considered as a whole, do not contain such toxic features. So the statement simply does not have any meaning. I think that people making such statements, assuming they are not making them merely as insults (which very often, historically, they are, although I assume not here), make them because they are confused. What they really mean, at best, is that certain implementations of Lisp-family languages of which they have (often apocryphal) experience have been rather slow. In fact what they usually mean is even weaker than that: some particular programs (which someone told them about) run in some particular implementations were slow. But somehow this becomes generalised to 'Lisp is slow': I think it would be interesting to understand how this generalisation happens, although its probably even more off-topic here than messages about Lisp are. To bring it slightly back on-topic, I think these statements are very like statements along the lines of 'Unix is insecure', which I think we could all agree is meaningless: a particular implementation of Unix might be insecure, but I think the claim that Unix is *inherently* insecure simply has no content. Finally I'll just add this quote about Stalin, a Scheme compiler by Siskind: "Stalin is the highest performing Scheme compiler and one of the highest performing compilers for any language".