Every once in a while, some kid discovers Lisp and thinks, “hey, that's actually a pretty neat language, why not use it for more than just school?” Well, there are reasons not to do that. Lots of them, actually. That's because Lisp just can't compete with Java in almost any imaginable way.

Lisp is not Web-ready

First of all, since Lisp has only one data structure—lists—it has no way of representing XML or HTML data. Since XML is the basis of the Web, you cannot provide enterprise-ready web services using Lisp as you can in Java. So what are you going to do with it? Exactly. You might as well stop at this point.

Lisp does not support enterprise features

In Lisp, there is built-in support for neither SOAP nor CORBA. This alone makes the language impossible to use in an enterprise setting, since there is no way of accessing cloud-computing or multi-tenancy services without being able to encode requests in enterprise-ready cloud communication formats.

Lisp is slow

You would think that with electrical energy becoming more expensive each day, people cared about efficiency and scalability. Not so—anyone using Lisp is using an interpreted language with huge memory requirements. Also, you can't use Lisp in an interactive application, since garbage collection can kick in at any time and stop your program for a couple of seconds at a time.

In contrast, Java and C# programs are compiled into efficient bytecode and run on an advanced, highly optimized virtual machine. Also, specialized CPUs like ARM Jazelle grant Java applications native performance—Lisp just can't compete with this because it is much too complex to implement on the metal.

Lisp is too old to be useful

Did you know that Lisp is from the 50s? It hasn't changed a bit since then. It's still the same academic parenthesis mess lacking any kind of consistency or reasonable design, and it's still all based on lists. This is in contrast to C# and Java, which are much more modern designs based on real-world experience with enterprise C++ application programming.

Lisp does not have any advantages

I know, I know, Lisp was innovative for its time. That time is long over, though. Other languages have a GC, other languages have slow interpreters, and other languages have a REPL. Get over it.

Lisp is inappropriate for teams

Granted, there is one thing that Lisp has which other languages still lack: macros. But really, using macros in production code is a disaster waiting to happen. With functions, you at least know what the evaluation rules are. But what if you call a macro like the following?

(with-open-file (file "test.txt" :direction :output)
  (print "hello" file))

This might open a file called “test.txt” and write “hello” into it—or it might reformat your hard drive! How are you to know?

Things like this make Lisp impossible to use in a team setting. Give people too much freedom, and they will do stupid things with it, annihilating any hope of documenting the resulting mess or, God forbid, making it maintainable. Enterprise languages like Java abort compilation even when dead code is detected. This makes debugging much easier.

Lisp's features have become obsolete

As can be seen in enterprise C++ applications, garbage collection is pretty much an obsolete feature, since data is practically never managed manually within the program. Instead, everything is stored in highly optimized XML databases, which gives you more flexibility and scalability. Other features, like CLOS and the condition system, have similarly become obsolete by advancing technology.

Face it: Noone cares about “interactive programming”

Then there's this neverending talk about “interactive programming,” as if that was something desirable. In Lisp, you apparently type stuff into the REPL instead of writing it into files. Great! Except... you can't store the code in files that way. Lispers tend to learn their lesson the hard way, as all code is lost when you need to reboot your computer. But then again, noone bears to write Lisp code more than 100 lines long anyway, so it probably doesn't matter much.

Tool support is stuck in the '70s

Whenever you see a misguided newbie ask on an online forum which IDE they should use for Lisp, the answer is always the same: Emacs. Really. These guys prefer an editor from the 70s over an enterprise-class IDE like Netbeans or Microsoft Visual Studio with innovative features like syntax highlighting and documentation lookup. Masochism is the only valid reason for this, but since you need to be a masochist to program in Lisp in the first place, that's not surprising.

Practically all Lispers are Smug Lisp Weenies that are a bitch to deal with

Really, the most annoying aspect of Lisp is that its followers are smug weenies. Every single one of them. You can see this on Usenet: Whenever someone writes an objective article about the benefits and disadvantages of Lisp (like this one, for example), the trolls come out and hammer you with flames. How can a community expect to garner support for its cause if it reacts so hostilely to constructive criticism?

The fact that so much of the Lisp community is centered around Usenet is a bad sign in and of itself. Do you think that successful companies like Google or Amazon ask Usenet for support? Get a grip on reality here for a moment. Real programmers don't rely on net punks for support. They have learned to buy commercial-grade enterprise support, and so should you. Good luck finding a Lisp support company, though—they've gone extinct around 30 years ago.

Lisp is used by noone

Because of all of the above, nobody actually uses Lisp for anything that approaches real-world programming. In contrast, lots of people have made real money using Java and .NET. Everyone knows that swimming against the tide is equivalent to doom. Therefore, it would be prudent to do it like the big ones and avoid Lisp like the plague.

Noone can read Lisp syntax

Finally, just look at the following typical piece of Lisp code:

((lambda([])((lambda(|| |()| |(| |)|)(+ || |(| 1 |)| |()| |(| |(| |(|)) [] [] [] [])) 0)

It's true, that's completely valid, real-world code! Can you guess what it does? Yeah, me neither. And did you notice that the parentheses aren't even balanced? Simple syntax—yeah, right.


You can draw your own conclusions based on the points above. However, before you do that, I advise you to take a close look at this article's publishing date. Happy programming!