Lisp Sucks

It sucks because you really can't build big applications with it unless you want to write a lot of stuff that other languages already have.

This is true for any language without industry support.

To paraphrase a great bumpersticker: 'Lisp sucks less.'

This is only sort of true. You can't build the kind of plug and chug applications as easily as you can in VB or Java by leveraging a huge number of libraries. However, if your problem space doesn't happen to be already substantially solved by these libraries, you can build a big application much faster in Lisp. So I agree, in very mainstream, so-called 'enterprise' business apps, there is a lot of stuff that is harder to leverage (but there are ForeignFunctionInterface and even COM capabilities in some lisps), it may take longer. However, your comment certainly doesn't generalize.

You can interface with C API's easily from any CommonLisp implementation to gain access to the underlying platform and components. Anything you can call from C or CeePlusPlus, you can use from Lisp.

[Really? Like common commercial libraries?]

It sucks because you really can't build big applications with it unless...

Personally, I think big applications are probably a DesignSmell. One should find a way to divide it into smaller applications. See SystemSizeMetrics

Also, I had trouble with the format of a lot of the macros. They make it so you have to remember exactly how every macro works to understand the code. This is very different from something like Smalltalk, where all the arguments are named and anything that isn't evaluated is in a block. I think this is the main reason people hate Lisp.

No, complete ignorance of Lisp is the main reason why people hate Lisp. The individual who has a technical, rational reason for disliking Lisp, based on having a big clue about Lisp, is vanishingly rare.

You can run into trouble with macros, but I have never really had the difficulty you describe. The language has very good introspection, and if your code is written sensibly a call to describe should sort out any confusion that was left after your editor told you what the arguments to your macro should be.

The standard macros in Common Lisp are quite well designed; they are for the most part seamless abstractions that do not require you to understand a particular implied macroexpansion.

Shouldn't this page be titled "(sucks Lisp)"?

No, but rather (sucksp 'lisp).

Or perhaps (assert (sucks? 'lisp))

No, the Scheme programming practice of using ? character in the names of symbols that designate predicate functions is a bad idea. You may want to use it as a macro dispatch character at some point. You will then be only able to use it as a non-terminating macro character, meaning that when it occurs in the middle of a token, it does not terminate that token but is treated as a constituent. Assuming you didn't ever use it at the start of a symbol, or as the entire symbol.

On what occasions have you used "?" as a macro dispatch character?

Well, I'm not the original poster, but I've used it to create logic variables (for unifiction), i.e., ?x is a variable. See the languages HORNE and RHET in the University of Rochester CS Dept. TR Archives. As far as I know it's not rare to use it for such (particularly when constructing an embedded language - one of the nice things about Lisp and macro dispatch characters!).

Lisp has its limitations, but anywhere you want an untyped language that isn't blazing fast, Lisp is good. Examples of this are as the extension language for AutoCad and TheGimp, and a web site driver for Yahoo Shops and one of the big flight reservation systems. [Er, well, actually the big flight reservation system does need to be blazing fast. Fortunately, Lisp is well able to be blazing fast.]

GIMP has an unoptimized SchemeLanguage (not Lisp) implementation embedded in it. AutoCad contains a Lisp-like scripting language. Not everything that uses parenthesized notation is Lisp! The parentheses don't make something Lisp any more than curly braces make something C.--[comment edited to remove excess bile]

Ah, the beauty of Wiki. When you don't like something someone wrote, making it disappear is just a few clicks and keystrokes away. Hey, freedom of speech should include the freedom to make other people's speech disappear---for the sake of operational completeness! You gotta have the full CRUD: create, retrieve, update, delete. :)

Scheme is commonly considered to be a dialect of Lisp, just like there are many different dialects of Basic, Smalltalk, Forth, etc. AutoCad even calls their version AutoLisp. These are full fledged Lisps, unoptimized because speed in an extension language is not of primary importance. Python and JavaScript also seem to be popular extension languages. I was pointing out that Lisp, being a dynamic language, seems to do well in this area.

For the last what, 20 years or so, if you are talking about "Lisp" without specification, it will be assumed you mean "Common Lisp", as defined by the ANSI standard. In certain contexts this will not be true, but that is really beside the point as the same can be said of "C" or what have you. Common Lisp is and always has been an industrial strength language with efficient compilation and support for large projects. It has some strange warts related to its upbringing, but considering it in the same breath as something like the embedded scripting scheme in GIMP is just silly.

NOTE: tons of useless and distracting assembly moved to LispSucksInAssembly to reduce clutter.

I don't see any material here that actually supports the thesis that Lisp sucks. Are we reading the same page?

There don't appear to be any jokes here either, at least not anymore. This page lacks the charm of WhyWeHateLisp. -- LukeGorrie

That's because that page was written by some people who had actually used lisp. Any X sucks page will always be much better if written by someone who knows X intimately; indeed, when this is the case, the whole thing can be marvellously funny (e.g. TheUnixHatersHandbook). This page, however, seems to be the sort of ignorant whining one normally associates with the slashdot crowd. -- AlainPicard

Ahh, yes. Spoken like a true SmugLispWeenie. (heh)

(format t "~a-~2,'0D-~2,'0D ~2,'0D:~2,'0D:~2,'0D UTC" yr month day hr min sec) ; At least printf has a man page...

Feh. As NiklausWirth rightly pointed out when designing ModulaTwo, formatted display is almost always the WrongThing, anyway. - JayOsako, a SmugSchemeWeenie?

while there are similarities, format is far more capable than printf and the CL hyperspec is vastly superior to man pages. What was your point?

I had a heck of a time finding out how to do that. I have two LISP books on my desk, both of which give examples of things that are not quite what I wanted to do and neither of which gives a complete definition of the format controls. Meanwhile, most of the links I clicked on in the hyperspec just sent me to the definition of what something is instead of to the part of the spec that explains how to use it. Finally I found the right link, put in the format control, got an error, made a wild guess that I had to quote the zeros, it worked... Then I sat back, looked at the resulting code and said yuck, what an ugly language. LispSucks.

Hmm. Lets see now; the usual way to get to the hyperspec is through your editor, which will lead you to the page for the format command. If don't have a decent lisp editor handy, you might start off at the top level table of contents. In either case, one or two clicks will lead you to the obvious place to start looking: "22.3 Formatted Output". Like man pages, this is not newbie documentation, so I agree it might take a few more clicks if you are completely confused. Of course with your two Lisp books you should know at this point that you are looking for information on printing and formatting, so I assume you found this page. Why did you make a wild guess? Right on the first page is an example:

"For example, ~5,'0d can be used to print an integer in decimal radix in five columns with leading zeros, or ~5,'*d to get leading asterisks."

It can hardly get easier than that; you don't even have to follow the obvious link to "Examples of Format" at the bottom of the page (which would also have shown you how to do this). Format strings can look a bit ugly, sure, but compared to most languages' I/O they are amazing. Conditional pluralization, flow-control, sane layout control....and you want to dismiss this all out of hand because you can't read a page of hypertext to find the example handed to you on a plate?

Please forgive this unwashed C programmer for having started with the index instead of reading from the beginning. It sent me into the circular morass of the glossary, which apparently is the fate that awaits all those who dare to Lisp without a special editor.

Ahhh, I see. One of those "I don't need no stinking IDE" programmers, and God forbid you actually read a manual.

How nostalgic... Reminds me of APL, which needed a special editor because it was written in some Klingon character set.

Not a special editor, just a decent programmers' editor. You know, the kind you can add hooks too; like lookups in some set of docs like the hyperspec. Hell, I was an unwashed C programmer when I learned lisp too, but even then I think I would have looked in the table of contents. Indices are for when you know what you are looking for. I certainly wouldn't suggest to someone that they learn lisp from the hyperspec, that isn't what a spec is for in any language. I don't know which 2 lisp books you have, but are you sure you didn't miss an example right in front of you there, like you did the one above?

Graham, Section 7.3, "Output," is mute about the D format, but makes the observation "Depending on one's point of view, format is either amazingly powerful or horribly complex. There are a large number of format directives, only a few of which most programmers will ever use." (I'm the only person who needs to print ints?) Ironically, the index has an entry for "printing times" -- exactly what I wanted, but not how I wanted it. He used A instead of D, so it was extra-ugly and didn't make sense to one who just wanted to print some ints.

My other book is Winston & Horn... NuffSaid?

You're going to judge an entire language by its formatting controls and by what you think about a couple of books? By that criterion you should love COBOL, which has very friendly formatting.

I think LispSucks because I haven't found anyone that will let me code in it, yet. -- BobBockholt See also: ArmyOfProgrammers.

Now that's the best reason I've seen yet, and quite true. I'd say the same for SmallTalk. I'd love to try either, but no one will let me.

Yeah, I'm an OS and language junkie myself.

And let me make that 'let' clear:

I've taken stabs at getting a handle on lisp and scheme (and SmallTalk (which actually went better than most, thanks to Squeak!), and ErLang, and Dylan, and ML, and Haskel...) more than a few times. I spend a couple of hours, cltl2 in hand, looking at examples and coding up some simple toys, but end up throwing in the towel because the learning curve is quite steep because of the size of the vocabulary, the body of idiom, and, not least, the paradigm shift. But a month later it still calls to me, "C'mon Bob! You know you want to be a big, bad lisp programmer!"

I read on some lisp evangelism page that a company would do better to hire a 'few really smart lisp programmers' than a legion of typical C programmers. Maybe I'm just not smart enough, yet? Maybe stupidity is why lisp sucks?

I don't see any substantial support of the thesis on this page... perhaps that has been edited out?

Yeah, probably. SmugLispWeenies are like that. <ahem>

[Oh, I doubt that. A SmugLispWeenie may laugh at you, even correct you harshly, for saying something ignorant or stupid about lisp, but she is unlikely to DisagreeByDeleting.]

[[Actually, they have proven themselves to be pretty bad vandals on the anti-Lisp pages.]]

The fact that mainstream employers don't want to take the risks of investing in lisp can be a great advantage to small companies because it lets them undercut the delivery time and price of much larger competitors by using superior development technologies.

Excuse me? "Superior development technologies?" Could you name any two, please.

Use. Lisp. :P Jokes aside: use what's best and not what's the most popular. Hardly a technology, but still important. -- Baczek

What is the best though? That's often a tough decision. I've yet to find, for example, the best relational database tool. There aren't any because they all suck and fail to exist. One problem with smug lisp wheenies is they literally think lisp is the best tool for all tasks, and they think lisp is literally the GoldenHammer. PaulGraham strikes me as such a fellow. Paul Graham is the type of naive person that rejects databases and thinks flat files are the way to go. He has written articles advocating using lisp and files instead of an RDBMS, because he literally thinks Lisp is the best tool for all jobs - this strikes me as religious and ideological (not to mention ignorant). That's why many of us write off smug lisp wheenies like Paul Graham as quacks/cracks/crankpots.

I read on some lisp evangelism page that a company would do better to hire a 'few really smart lisp programmers' than a legion of typical C programmers. Maybe I'm just not smart enough, yet? Maybe stupidity is why lisp sucks?

Hiring "really smart programmers" as opposed to a "legion of typical programmers" is often a good thing to do, regardless of the languages involved. Of course, identifying wheat from chaff is frequently very difficult to do; nobody puts on their resume that they are a coder of average capability. I've encountered many poor programmers who nonetheless had impressive resumes, glowing references, and flawless interviews.

And no, the claim "really smart programmer := Lisp programmer" will not be accepted at face-value.

[Of course not, that claim would be silly. It is (fairly) highly correlated, not causal]

What?!?! But the ad said "Learn Lisp! Guaranteed to raise your I.Q. by at least 40 points!" Are you telling me I wasted my $29.95??? :-( [Well, probably not wasted. I expect most programmers would become better programmers by learning a lisp (if they haven't already) even if they never `use' it. This isn't unique to lisp, of course.]

{Why is the really smart programmer being assigned := a value of Lisp programmer? Shouldn't it be checking for equality?}

Lisp (CL) sucks because you can't write very small programs in it. Every available practical environment today (ie not LispMachine) is a humongous thing that has to be started in a separate virtual machine. You always need a separate launcher. It also encourages people to save running images instead of sources. -- AnonymousCoward, hoping someone will prove it wrong

  1. Current Lisp runtimes aren't really any bigger than Java virtual machine runtimes, and is at least in the ballpark of Perl, Python and Ruby. Maybe that's humungous, but it's also normal and acceptable.

  2. I'm not sure what to make of You always need a separate launcher. I *think* what you mean is that you need to start the virtual machine process to run the program. See the first point. This has become common for a number of widely used development languages. Also, you *can* make standalone executables which have a small VM stub prepended to the image with most CLs.

  3. While you can save running images instead of sources, it's not necessary, and I think it's done mostly for application delivery and not for development. Most people develop CL with an IDE or Emacs and save the sources to text files. They use a defsystem facility (such as asdf) to automate loading source files into a running image. And, saving images has both drawbacks and advantages. Most environments don't even give you the option.

  4. Lisp is not C, that's for sure. If you want C, you know where to find it.

Its been a long time (about 8 years) since I've done much Lisp programming. But I still believe that my personal productivity with CommonLisp and CLOS was *much* higher than with any other environment that I have used (C,C++,Java,DotNet). However, balancing that was the horror that I often used to feel having to work with other peoples Lisp code, sometimes it was lovely but it could also be more confusing to me that the worst perl or overloaded C++ code. Somehow I think "With great power comes great responsibility" also applies to (ab)use of overly powerful programming language features.

[See ThreeStarProgramming. See also ThwozzThwozzThwozz and WorseReallyWasBetter, a personal rant in favor of C (honestly).]

NOTES:

  1. This page originally started out as CategoryJoke, but them moved into the mainstream by the addition of much material to actually support the thesis. Hmm. Where there's smoke... a crowd gathers to see what's going on.

Can't we merge it with WhyWeHateLisp or the like?

See: XmlSucks, WhyWeHateLisp, SmugLispWeenies, SocialProblemsOfLisp, SucksSucks, GreenspunsTenthRuleOfProgramming, GreatLispWar

CategorySucks, CategoryRant CategoryLisp

EditText of this page (last edited September 30, 2014) or FindPage with title or text search