The curse of Lisp is not its power, elegance, flexibility, etc. The curse of Lisp is its syntax! Both "all those parentheses" and what they represent is the curse of Lisp.
Lisp forces coders to think in terms of infix trees. These trees need to be carried around in the front of the mind. This mental model is very difficult unless your mind is wired to be able to process code this way. For Lisp aficionados this either comes naturally or with coding practice. The "parentheses" fade into the background. For most people this wiring never comes. It remains too difficult to keep the nested trees straight in their heads. To put it colloquially, it's too difficult to juggle all those parenthesis.
If you're a Lisper you'll want to believe that with use comes the familiarity to overcome this hurdle. It's not. If you're a Lisper your probably tempted to redactor a sample chunk of code into something really readable to show this isn't the case. However, that only works in the small. It's like code golf. It doesn't carry over into large scale applications. Lisps mental model just won't become second nature to very many coders.
Haskell forces you to juggle "math." Forth forces you to juggle "stacks." Lisp forces you to juggle "trees." The popular Algol descendants are popular, in part, because they're closest to the way people think. The curse of unique brains is the curse of Lisp.
> The popular Algol descendants are popular, in part, because they're closest to the way people think.
No, those languages not close to "the way people think", unless those people are already experienced programmers using one of those languages.
Programming languages are artificial and do not work like human languages. Every programming language requires you to run an internal parser and build partial parse trees in your head to under stand what the program will do. Whether it's Lisp, Java, or anything else.
Lisp is not any harder for beginners than any other programming language.
> It doesn't carry over into large scale applications.
It works far better and more powerfully in large scale applications. Lisp is unmatched in its ability to write large applications, in terms of power and functionality, with fewer developers and fewer lines of code than almost any other language. This is pretty much the whole point of the "Lisp Curse".
And no, it's not code golf. It is higher order, more powerful abstractions and coding techniques.
Programming languages were created in order to bridge the gap between our minds and computer hardware. Why wouldn't each language be created in a way that the language's author(s) believed best to bridge that gap? Most of these first era languages were available on every platform. People picked the language that worked best for them. The language that "spoke" the most like they did.
>> It works far better and more powerfully in large scale applications. ... This is pretty much the whole point of the "Lisp Curse".
That's the premise of the article. I believe that premise is incorrect. Lisp may be a higher abstraction but it's a more difficult abstraction for many programmers to think in. As I stated, I believe that's a direct result of its syntax and all that syntax entails.
> Algol descendants are popular, in part, because they're closest to the way people think.
All it takes is 10 or 12 years of schooling, and suddenly people realize this is the natural way to think! Except for all the exceptions like pow(x, 2) which nobody can figure out. Or x=x+1, which flies in the face of those past 10 years of schooling.
Algol, of course, still makes you juggle math, stacks, and trees, but they’re completely invisible so you have to keep them in your head, along with the bidirectional mapping to the complex syntax required by the compiler. But what you can’t see can’t hurt you, right?
C, Forth, Lisp these were all "first era" languages. Each had a chance to be used, to grow, to spawn other languages. To become the common way of thinking. Nobody forced the paths each language took. They grew organically. As people taught themselves how to code they picked the language that was closest to the way their minds worked.
>> Algol, of course, still makes you juggle math, stacks, and trees ...
Agreed. It just does so in a way more comfortable to the most number of people.
> C, Forth, Lisp these were all "first era" languages. Each had a chance to be used, to grow, to spawn other languages.
Do you have any idea of how much is there from Lisp in e.g. Javascript and Python? With the only exception of prefix notation - there is a LOT of things directly inspired by Lisp in many modern languages.
Comfortable to the most number of people? Following the same logic we can conclude that Mandarin is the most comfortable spoken language, because it's the most common language on Earth.
>> Do you have any idea of how much is there from Lisp in e.g. Javascript and Python?
Absolutely! I'm not saying that Lisp is a bad language. I like Lisp (and Forth). I'm saying that its syntax (and the why of its syntax) are the primary reasons it hasn't caught on. I'm just not buying the "too powerful" and such arguments.
>> ...we can conclude that Mandarin is...
Most people pick their spoken language by their surroundings and what their family speak. Children aren't making a choice. In the early days of computers when the root languages were being created everyone had a choice. Maybe not as much now but still anyone can pick up new languages during their careers.
That's where you got it all backwards. Lisp (as an idea) after six decades is still thriving. There is a Lisp dialect for almost any platform. Clojure surpassed in popularity languages like F#, OCaml and Haskell, even though they are older than Clojure. There are more Clojure conferences, more meetups, more podcasts and more jobs. There are regular conferences in the US, Canada, Brazil, India and in almost every European country. Some of them have multiple Clojure-focused conferences. Emacs and emacs-lisp is still being developed and used by thousands around the world. Common Lisp is still in use. Racket is pretty popular in academia and beyond.
Again, Lisp is just an idea. If you grok the awesomeness of that idea you may someday find what makes it so powerful. Lispers often talk about "enlightenment" and call Lisp "a secret alien technology". They don't do it simply to justify their choices or to create aura with elitist attitude to scare outsiders.
Akin to the idea of Vim as a modal text editing - it takes time to get it, to learn it, to understand it. But one day you may realize the power behind it. Most people, being spectators don't get it. Sometimes people would learn just the basics of Vim, move onto something else and would be like "meh". But those who stick around, they soon may find an incredible new world that changes their subjective view and understanding of how things work. And they realize that there's nothing that can convince them to "unsee" this new world of possibilities. And just like there are many Lisp dialects, there are many ways to run Vim. You can do it in almost any modern IDE and editor.
Lisp is the same. It is a simple but quite powerful idea, if you don't see its power - perhaps because you haven't really looked.
Unfortunately yes, that's not the best way to "sell it", but that's the truth. You have to be a Vimmer to see the power behind modal editing, you need to become a Lisper to see true power of Lisp. That is why neither Lispers nor Vimmers have any illusions - they know, their way of thinking will never become mainstream.
I'll agree that the ideas and power of Lisps have caught on and are even pervasive. Just that "thinking in Lisp" is what I believe has held it back.
I have fond memories of a number of editors: VIM, EMACS, VEdit, and KEdit (Rexx scripting). When the mouse centric editors appeared on the scenes I found they worked better for me. As someone who has coded in Lisp, Forth, C, etc. and in a wide variety of editors I guess our experiences differ.
> I have fond memories of a number of editors: VIM, EMACS ... When the mouse centric editors appeared on the scenes
End 70s on the Lisp Machine (had a megapixel bitmap screen, mouse and GUI) with the Zmacs editor. The second Emacs ever written and the first one written in Lisp.
> Haskell forces you to juggle "math." Forth forces you to juggle "stacks." Lisp forces you to juggle "trees."
Javascript forces you to juggle semicolons, Python forces you to juggle indentation, Java forces you to juggle nested class hierarchies, XML forces you ...
Indentation and semicolons don't impact the number of things your mind has to remember at one time. Nested classes are a problem as we're finally seeing with a bit of a backlash against OOP these days. XML is just markup and not a programming language so there's no "action" that needs to be carried around.
It's not the hierarchy itself that's the problem. The difficulty is remembering all that the hierarchy is doing before setting a chunk of it aside that causes the problem. Especially prefix trees.
> Indentation and semicolons don't impact the number of things your mind has to remember at one time.
I disagree. It didn't feel like impeding factor back in the day when I was writing Python, C#, Javascript, Typescript, etc. But working in Lisp I realized how many things I used to deal with, constantly shifting my focus to properly style, indent and punctuate the code so it would work and look easier to reason about.
Writing Lisp is more like writing poems without having to worry if it rhymes or not. You can write code just as you would draw prototypes on a piece of paper. Except you can evaluate any part of it without any preceding ceremony. Some prefer to start with smaller pieces and compose them, some would just write it "imperatively" and then break it apart. You don't have to worry about operator precedence, about reserved words, semicolons, all the unnecessary garbage. At the end of the day you realize - the visual garbage that's what it is. It supposed to make code more readable - but in reality it does not, it distracts more than helps. Human brain is fascinating, it plays tricks with you - once you see a dot in the middle of a visual illusion, you lose the ability to "unsee" it. But most people may still try to convince you that there is no dot.
Please stop spreading nonsense. The syntax that may be a bit unfamiliar to uninitiated stops being an issue within literally hours. It takes a few days to completely become comfortable with it. I have seen people learning Clojure as their first language, I've seen people coming from other languages. But I have never met anyone who actually wrote Clojure for a few months and still couldn't get used to the syntax. Only people who are completely unfamiliar with the language do sometimes complain about the syntax. Because again - to uninitiated it doesn't look very familiar. Just like indo-arabian numerals looked strange to Europeans in 13th century.
The syntax of lisp is objectively bad from a UX perspective since it doesn't properly separate different kinds of objects. Our brains are very good at parsing symbols and very bad at parsing text, and lisp forces you to parse text to understand the structure of the code. That is great for computers to parse and generate since the structure is uniform, which makes lisp great for meta-programming, but it also makes it a horrible language for humans.
Any language which PL enthusiasts considers elegant since you can do so much with few abstractions will be a really bad language in practice since humans prefers different kinds of code to have different syntax and look different.
>The syntax of lisp is objectively bad from a UX perspective since it doesn't properly separate different kinds of objects.
I still don't understand what kind of objects you're talking about and why they need to be separated? Why pencil.writeOn(paper) is a good UX and (pencil.write-on paper) is a bad UX?
> Our brains are very good at parsing symbols
Are you saying we should be all using APL? Point me to a single academic source where it says "from neuroscientific point Lisp syntax is not so good for humans". For the same reasons why Sanskrit writings would not be very easy for me to read, Lisp is not very easy to read to some people. And the reason is - unfamiliarity. But does that mean that written Sanskrit is a bad UX or it can't convey information or used effectively as a language? I will state again: I have never met a single person who after writing Clojure for a few months would still complain about its syntax. Not saying they don't exist, I just have never met any. Besides - after writing Lisp for a few years I find it a bit difficult for myself to read code in other languages - Python, Javascript, C, Rust, etc. And I have been programming in non-lispy languages for over twenty years. I also personally know a few programmers who started with Clojure as their very first PL and then later tried to learn another, more traditional language and they all have struggled. It took time for them to adjust to new, unfamiliar syntax. ALL of them said that they prefer Clojure syntax.
> and lisp forces you to parse text to understand the structure of the code
How is Python, Javascript or even SQL are different? You still have to mentally parse the text to understand structure of the code
> Any language which PL enthusiasts considers elegant since you can do so much with few abstractions will be a really bad language in practice
That is why Lisp refuses to die? When Fortran is forgotten, COBOL completely dead, C replaced with Rust and Java with Scala and Kotlin, PHP gone and Ruby becomes unpopular, there still will be at least a few dialects of Lisp still very much alive and thriving.
Take Emacs for example. For decades different IDEs and Text editors been trying to "kill" Emacs, yet it still thriving and still being used and packages written in emacs-lisp are in abundance and new ones being developed all the time. Check Github stats for different languages - you will be surprised of how much emacs-lisp is published on Github alone.
"Really bad language in practice" turns out to be very pragmatic choice, otherwise how would you explain that Clojure been successfully used at companies like Apple and Walmart, at NASA and many other https://clojure.org/community/success_stories. There are multinational companies like Funding Circle that have built their businesses on Clojure.
Many seasoned CS veterans repeat over and over: "Learn Lisp if you want to master the art of programming".
So if you don't get Lisp syntax - it's just you. You aren't used to it, it's unfamiliar, that's all. But there's nothing inherently "bad" about it.
Sigh. Somebody always says this and it always sounds just as narcissistic.
"My brain cannot handle parentheses, therefore no brain can handle parentheses."
There's no sin in saying "I don't like parentheses." But please, please stop generalizing that to "most people" because you really, really have no idea.
Sigh. Somebody always responds without reading the full comment.
"I don't like part of the first sentence therefore there's no need to consider the rest of what the comment says."
There's no sin in saying you don't agree with a comment. But please, please stop taking one point out of context just because it pushes personal "anger buttons" because you really, really have no idea.
Lisp forces coders to think in terms of infix trees. These trees need to be carried around in the front of the mind. This mental model is very difficult unless your mind is wired to be able to process code this way. For Lisp aficionados this either comes naturally or with coding practice. The "parentheses" fade into the background. For most people this wiring never comes. It remains too difficult to keep the nested trees straight in their heads. To put it colloquially, it's too difficult to juggle all those parenthesis.
If you're a Lisper you'll want to believe that with use comes the familiarity to overcome this hurdle. It's not. If you're a Lisper your probably tempted to redactor a sample chunk of code into something really readable to show this isn't the case. However, that only works in the small. It's like code golf. It doesn't carry over into large scale applications. Lisps mental model just won't become second nature to very many coders.
Haskell forces you to juggle "math." Forth forces you to juggle "stacks." Lisp forces you to juggle "trees." The popular Algol descendants are popular, in part, because they're closest to the way people think. The curse of unique brains is the curse of Lisp.