Blog /  
What is the Curse of Lisp: Challenges and Opportunities

Myths of LISP: Curse That Didnt`Really Happen?

November 10, 2021
8 min read

What is the curse of Lisp and how to break that spell? Is it bravado, myth, or a real phenomenon? What curses and powers did Lisp-family languages inherit?

Let's dispel the myths together!

What is the curse of Lisp (and who cares)

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 <medium>canonical (and misunderstood)<medium> his linguistic masterpiece became.

LISP Curse

<medium>LISP (List Processing Language)<medium> 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. <medium>JS, Python, and others inherited a lot from Lisp.<medium>

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!

<medium>"The power of Lisp is its own worst enemy".<medium> 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 <medium>lone-wolf tendency, throw-away design, poorly documented and unportable systems, tooling 'entropy'<medium>, 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?

Curse or blessing? Myths, issues and solutions

The pow­er and expres­sive­ness

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. <medium>Lone wolf developers and scratch-an-itch model.<medium> 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)'.


lisp programming

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é.



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.


Clojure vs. LISP: Acquired and inherited traits

Power of Clojure

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.


One of the most mentioned Clojure benefits is its community. And it's really distinct from other Lisp communities. High level of collaboration, users full of enthusiasm, and all the delights of mutual support — this simply cannot leave you indifferent. Here you can check our research dedicated to the topic of Clojure community challenges: Mythbusters: Why Are You Shouldn't Be Afraid About Clojure.

There are enough Clojure conferences, meetups, blog posts, and podcasts. Clojure attracts developers' and businesses' attention. May it be so!


You'll never walk alone: Lispers insights

We ask our programmers to describe their experience with Lisps and share their thoughts about the Lisp curse.





Wrapping up

To play guitar like a Van Halen it's not enough to learn chords and copy his tapping technique. You should understand how are guitar scales formed and truly understand the instrument. Then you can play it without tabs, sighs, and cursings.

To understand Lisp you should become Lisper. Are you ready? :)


We don't claim that Lisp-like language is the silver bullet. But it is worth trying. <medium>Embrace the Power of the Lisp!<medium>

Emacs is still being developed, Common Lisp is used around the world, Racket is popular within computer science education and research, and beyond. Clojure is thriving. You'll never walk alone.

Freshcode team is happy to expand horizons with Clojure and its best LISP heritage. We are ready to consult you on how to benefit from <medium>Clojure software development<medium> — please, fill our contact form.


Shall we discuss
your idea?
Upload failed. Max size for files is 10 MB.
Thank you! Your submission has been received!
Oops! Something went wrong while submitting the form.
What happens after you fill this form?
We review your inquiry and respond within 24 hours
We hold a discovery call to discuss your needs
We map the delivery flow and manage the paperwork
You receive a tailored budget and timeline estimation