I just read yet another recycling of the old myth of how some esoteric programming language (often Lisp or Haskell) is the secret weapon that allowed a team to outperform expectations by an order of magnitude. Paul Graham has strongly encouraged this myth (see Beating the Averages), but it has been circulating for ages. It is totally false. Worse, it reinforces the intellectual elitism that is the bane of our field.
The objective evidence we have is that the differences in programming performance are almost entirely due to the individual cognitive differences of programmers. It doesn’t matter what language a great programmer uses – they will still be an order of magnitude more productive than an average programmer, also regardless of what that programmer uses.
The anecdotal benefits of esoteric languages are a selection effect. Here is a common scenario. Lots of really smart programmers think they are too good to waste their talents doing mere application programming. But they also love esoteric languages that show off how smart they are. So you can get them to do application programming by letting them use their beloved smarty-pants languages. Presto, amazing results. But the ubermensch aren’t about to stoop to maintenance programming. Once the fun development is done, they are gone. When you bring in professional programmers to take care of things, they are dumbfounded by the towering monument to mental masturbation. The system gets thrown out and rewritten in a normal programming language using normal techniques that normal people understand. The super programmers blame it on the stupidity of the new hires, further confirming their sense of superiority.
There are no super programming languages, only super programmers. And they tend to be super jerks. I should know – I used to be one. What would really make a programming language be super powered is the ability to be used by normal people.
P.S. I seem to have hit a nerve with this! Methinks they doth protest too much. I responded to some points in this comment. The final paragraph bears repeating:
These kinds of claims are just thinly veiled bragging about how smart Lisp/Haskell programmers are. I actually agree that they are smarter. But ascribing it to the language is a form of tribalism: our language (country/race/sports team) is better than yours, so we are better than you. Language tribalism is a pernicious affliction on our profession and our art. Grow up, everyone.
P.P.S. I guess I was a little intemperate, and got it back ten-fold. Publicly calling out cherished myths and immature behavior is not going to win me many converts. I also probably overstated the science, which is old and ambiguous. Still, my experience is that when people talk about how great their language is, they are really talking about how great it makes them feel. That’s fine, programmers should use the language that makes them happy, and being happy could very well make them more productive. But programmers who dislike the language will probably be equally disadvantaged. And in any case, the effects are small compared to the differences between programmers. But it does raise some interesting questions: what are the factors that make languages more amenable to programmers? Can we identify specific cognitive styles or personality types and map them to specific language design decisions?
I am re-opening comments, so long as the discussion remains reasonable.