One of the most common myths about Lisp is that it's "dead".

Hell no, it's alive (and on top of it, it's cursed you know).

'The Secret Weapon', 'big-idea language', 'Arcane magic', — Lisp was destined to become something steeped in mystery. For example, to be cursed.

Spoiler: We are not adherents of the term 'curse'. Moreover, probably the author of the term has been surprised how canonical (and misunderstood) his linguistic masterpiece became.

LISP (List Processing Language) is the second-oldest programming language (after Fortran). It pioneered functional programming, spawned several dialects, and provided a lot of key concepts that we find across different programming languages today. It took its place and found a lot of apologists among developers. JS, Python, and others inherited a lot from Lisp.

Lisps enable to write large and complex apps, in terms of functionality, using powerful abstractions and elegant coding techniques. And now we come to the most important question: the power of LISP!

"The power of Lisp is its own worst enemy". Here is a counterintuitive property of a powerful programming language. And this is where the 'curse' begins.

Why does this Lisp's power eventually result in lone-wolf tendency, throw-away design, poorly documented and unportable systems, tooling 'entropy', and so on? Is it an inevitability, bad manners of programmers, or something else?

We went through different forums and blogs and found a lot of really witty and pertinent comments regarding the topic. We used them in this article and thank everyone quoted here for their sharp mind, eloquence, and sense of humor.

Well, let's belabor (I love this word regarding the topic) the Lisp Curse one more time to see what is hidden behind it.

So, ladies and gentlemen, what do we complain about?

Okay, here is our number one. The pow­er and expres­sive­ness. Lisp is a 'programmable programming language' that allows you to be user-extensible beyond the core language set. It lends itself well to explorative programming, rapid prototyping, and creating extensible macros.

The only question is "Are you able to cope with the power of the ring Lisp?"

Lisp is unpopular. Yes, you won't find Lisp language on the top of the charts kind of "the most popular language worldwide". But, firstly, 'ad populum' arguments are even irrelevant. Secondly, pure Lisp is something ancestral and is rarely used directly today. Lisp 'reincarnated' into dialects and blesses other languages with its concepts and ideas, including:

• higher-order functions
• recursion
• dynamic typing
• tree data structures
• prefix notation
• garbage collection
• exception handling

and others

Lisps have powered multiple platforms across different industries from e-commerce to data mining and modeling & simulation. It has been successfully adopted by multiple commercial vendors. Roomba vacuuming robot, Mirai that was used to model the Gollum character for the LOTR movies, Arrival's service platform (a British electric vehicle developer) — we can extend this list but better read about it in our previous blog article.

Lone wolf developers and scratch-an-itch model. A lot of things in Lisp programming are up for grabs. Often it results in mul­ti­ple com­pet­ing implementations of lazy evaluation, type inferencing, arrows, pattern matching, etc.

'Because you can be so powerful alone, you work longer alone'. Nothing criminal but it provokes some negative tendencies of individualism, such as reinventing wheels, throw-away design, and lack of documentation. Individual programmers often don't handle related parts of the problem which would make the program more useful to others. A solution to the problem is making collaboration 'easier than individualism (for people who care about thought and beauty)'.

Inability to finish things off properly. Future maintainability and portability are orders of magnitude more important than elegant code. It's a safeguard for commercial projects. Ask yourself 'who will be able to read my code?' and 'is it portable?'. Well-structured repositories of useful libraries attract users, who, in turn, add more libraries, thereby raising the popularity of the language, 'rather than reflecting its theoretical potential'.

Aura of elitism. To fully enjoy Lisp language you should become a Lisper. I like one man's quote "The curse of unique brains is the curse of Lisp". But I would put it a little differently. There is nothing particularly "unique" in Lispers' brains (sorry, guys). I'd better call them 'configured' or 'dedicated'. You should be prepared and motivated. This is enough. Liberté. Égalité. Fraternité.

Poorly-taught. Lisp programming is still associated with symbolic AI since the AI winter and often programmers are сomplain about the low level of teaching Lisps at university. It's a question about training programs and needs for updating.

Best mentors explain 'intimidating' programming concepts in an encouraging tone. So Lisp enthusiasts have to communicate the benefits clearly enough to motivate others to give it a try.

...and many people are still complaining about the syntax. But polish (prefix) notation and reams of parentheses take some time getting used to. Unfamiliar scares us. But the lion is not so fierce as he is painted.

And in lighter news: Clojure avoids the Lisp curse by design. But first things first.

Clojure is LISP 1 with some minor modifications. It shares with Lisp the code-as-data philosophy and a powerful macro system and hits the scene as a modern LISP that embraced the JVM. Clojure is able to use the JVM libraries and it has escaped a lot of that 'curse' problem.

But not everyone is fascinated by this. Some Lisp programmers find Clojure uncanonical and call it 'False Lisp', 'antithesis of the Lisp Machine' and the 'most explicit to date abandonment of the age-old Lispers' Dream, "Lisp All The Way Down"'.

I like the one more quote, 'behind every Clojure primitive there lurks Black Magic'. Something mystery and even fearsome again, you see? I find this witchcraft atmosphere of the Lisp world really cool! (no sarcasm in my tone).

In the same time, Clojure was called the most joyful programming language and there are many reasons why it rocks.