After discovering awesome power of Ruby that was somewhat inspired by Lisp I could not help but wonder if Lisp is truly “Lambda the Ultimate” as they say.
Some brilliant and smart people are writing essays about it, for example “Revenge of the Nerds” really got me hyped. It is a language that has or can have any feature any other language has (and then some). It came to my attention that 1(one) man was able to replicate most of the cool stuff from Haskell in 10000 lines of Lisp code. Wow!
Couple of alpha Lispers rolled their own OOP support like it was no biggie. Wow!
Seems like the sky’s the limit.
So what happend? I am not buying that syntax is making a difference. It’s strange on the first look, but since people managed to decipher Hittie language from staring at it for 10 or so years I think we as a human beings are capable of managing some parentheses.
Archaic method names that are result of a rich history and a 10 year standardization process are not helping either, but it’s hardly the cause of unpopularity.
My theory is that lack of choices that are pre made is Lisp downfall.
You have this (ball of mud as some would call it) that can be anything you need. But since there are no common values it’s hard to draw people together. This lack of common values might be the biggest problem.
Sure you can write a DSL that suits your needs, but how is that different than having a different language altogether.
Since there is so little pre choice, the glue that is supposed to hold a community together is too weak to draw enough people that would build up a momentum.
There is simply not enough to cling on to. Everybody gets to flex the language in any direction they want. This ability by itself is great and absolutely awesome, but it’s hurting community progress in the long run since the other side of that ability is less obvious but painfully present - fragmentation.
Every community has values it cares about. For example a Ruby developer has different values than a Python developer. If they talk about their differences, they acknowledge that there are merits to the both sides. It’s just that a specific blend of features that is already chosen suits and pleases them enough to stick around.
I would argue that even a bad choice is better than no choice.
This Lisp minimalism and flexibility being a problem is best described in these two great essays:
Although I had previously commented on how minimalist I want my life to be, I’ve found my limit–the point at which minimalism becomes madness, and that is lisp.
In this essay, I argue that Lisp’s expressive power is actually a cause of its lack of momentum. The power of Lisp is its own worst enemy.
I don’t believe Lisp is not winning because people are dumb and are not getting it as is somewhat implied by the initiated. Since I judge superiority by results, there is no evidence about Lisp being superior. Famous Reddit rewrite from Lisp to Python is an irony that was not mentioned as a plan in the “Revenge of The Nerds”.
They knew Lisp (they wrote their whole site in it) and they knew Python (they rewrote their whole site in it) and yet they decided they liked Python better for this project. The Python version had less code that ran faster and was far easier to read and maintain.
No Lisp is not the “Ultimate” choice. I believe it will never get any more traction than it already has. It is beautiful, elegant and flexible but not all that better as advertised. It certainly is a local optimum for being dynamic and flexible. It’s far from being perfect language or even a superior one.
I like this quote about Lisp from Smalltalk author:
Lisp isn’t a language, it’s a building material.
It is not a bad thing per se, it is just a conclusion. Lisp is more like a blueprint for a language with all its options still open.
If I get forever stranded on a deserted island I might choose Lisp and bend it in any direction I might need. I guess it would not be all that important since my battery would run out in about 5h. Also by that time I would probably already start talking to Wilson.
(As a side note. I think that Clojure made enough choices to be a winner. Its values are being functional, using immutable data, generic methods and some syntax reader sugar that deviates from Lisp while leveraging the JVM. It’s clear why some Lispers don’t consider it a “True” Lisp. Lisp really optimizes to be a programmable programming language with all the choices available.)