
Why we hate Lisp - helwr
http://c2.com/cgi/wiki?WhyWeHateLisp
======
whyenot
Why we love lisp: <http://c2.com/cgi/wiki?WhyWeLoveLisp>

------
dkarl
This was not written by somebody who spent much time learning Lisp. This was
written by somebody who gave up pretty quickly.

Quick summary/translation:

We want to be finished learning Lisp, and it makes us angry to encounter
evidence to the contrary. Even though we can't yet code a simple loop, we know
exactly the best way for you to help us, and it makes us mad if you try to
steer us in a different direction. We're grown-ups now and don't ever want to
be beginners at anything again.

------
jwhite
The SmugLispWeenies complaint always strikes me as a really poor excuse for
disliking lisp. If a cantankerous old so-and-so gives you a hard time and you
run away from the language because of it, I think it says more about you than
the cantankerous old so-and-so, and nothing about the merits and disadvantages
of lisp. Furthermore, there are lots of non-cantankerous old and not-so-old
people using lisp, writing about it, and publishing code these days -- the web
is full of good lisp resources. Google answers almost all my lisp problems for
me. That means you don't even have to venture into the SmugLispWeenies cave
most of the time.

After that, there are quite a few good books out there. I'm reading Doug
Hoyte's "Let Over Lambda" at the moment, which is lots of fun.

My current problem with lisp is not the SmugLispWeenies but the fact that
there don't seem to be any lisp jobs where I live :-)

~~~
astrange
There weren't many other communities when that page was written. If they were,
they weren't well-known.

At the very least, the only one I've heard of is on newsgroups, and most of
what I hear about _that_ is that if you asked a question some Norwegian guy
would flame you so hard you would _actually die_.

The best resource would be a practical tutorial as easy to follow as Learn You
A Haskell, or at least a language subset as easy to learn as quickly as C - C
being, of course, the best language ever invented.

If people get stuck at the level where they're just capable of arguing about
the loop macro, maybe you should get rid of the loop macro, or at least not
let them know about it.

~~~
jwhite
Good point about the age of the page. From what I've observed, things have
changed a bit in the last ten years or so, no argument there.

"Learn You A Haskell" is very good, and I haven't seen anything like it for
Common Lisp. However, Peter Seibel's "Practical Common Lisp" is quite close in
terms of target audience, and also very good.

I won't argue with the assertion that Common Lisp is hard to learn. PCL, pg's
"ANSI Common Lisp" and "On Lisp", and "Let Over Lambda" that I've mentioned
are a good start, but it can be difficult to get from the text book knowledge
to good, practical, useful programs.

That said, I don't think that it's the fault of Common Lisp. C is easy to
learn because it is small, but it is also C. (I'm programming C and Ruby in my
day job, and I love C, but there are times when I wish it had more of the
expressive and abstractive power of Ruby or Common Lisp.) Common Lisp is hard
to learn, but once you've learned it you get to program in Common Lisp.

Regarding LOOP: some people consider integral calculus difficult to learn.
Does that mean we should excise it from mathematics, or at least not let high
school students know about it? LOOP is part of the standard, so it's not going
away any time soon.

~~~
sedachv
'"Learn You A Haskell" is very good, and I haven't seen anything like it for
Common Lisp.'

It's actually inspired by Conrad Barski's 'Casting SPELs in Lisp'
(<http://www.lisperati.com/casting.html>), which in turn was inspired by Why's
Guide to Ruby (I think). Conrad Barski actually wrote a Haskell comic book
tutorial that predates 'Learn you a Haskell'
(<http://lisperati.com/haskell/>). Not only that, but Conrad's full-length
Lisp tutorial comic book, Land of Lisp, is due to hit the shelves in four
days: [http://www.amazon.com/Land-Lisp-Learn-Program-
Game/dp/159327...](http://www.amazon.com/Land-Lisp-Learn-Program-
Game/dp/1593272812)

~~~
jwhite
Thanks for those links!

------
agentultra
Yeah, more hand-waving holy-war non-sense.

Lisp is a great language.

You could probably compress this page a fair bit.

80% of arguments against lisp are superficial

15% of arguments are unsubstantiated

5% of arguments are good and come from SmugLispWeenies who've actually used
Lisp for many projects and get to know its warts pretty well.

~~~
Avshalom
_80% of arguments against lisp are superficial_

And? Death of a thousand paper cuts is still death.

~~~
nkassis
Has this ever happened? I don't really want to know actually.

~~~
rdtsc
But when it happens it's a nasty death, and leaves a sour taste in the mouth
of both those who are pro- and against- the said technology.

Those that "die" are upset because they bought into the technology, invested
time and energy into it, it didn't work out. BUT not because of one single
reason, but because a whole lot of small ones. It's frustrating to explain to
someone why it didn't work because there isn't one or two reasons -- it turns
into a long list of small claims that sound silly individually and makes the
one making them seem whinny and complaining for no reason...

And this gets the supporters of the technology upset. They see others
baselessly attacking their favorite tool.

EDIT: A prime example of this was the GNU/Linux desktop. New users would try
it, it kinda worked, except when it didn't. Major things were "ok" but many
small things were not polished. And the Linux geeks just heard a lot of small
complains and couldn't understand why everyone "hates" GNU/Linux for no
apparent reason.

~~~
agentultra
I wasn't invalidating the criticisms themselves actually. I was suggesting
that there were a lot of repeat criticisms that we all know and hear all the
time. 80% of the page are the same criticisms of syntax, keyword names, prefix
notation, and structures. One could probably reduce the length of the page by
a significant amount if they just replaced it all with a single <ul>.

The criticisms of Lisp are nothing new. The language has been around for a
dogs age. There are going to be people who will never like parens or silly
keywords like cons, car, and cdr. Personally I find it equally silly when they
claim such superficial reasons are why Lisp is a terrible language. Every
language has to deal with some amount of this weak argument. Lisp is no
different, so I have no qualms with the argument itself.

If Lisp doesn't work for you, it doesn't work for you. It's no reason for
"hate". :p

~~~
rdtsc
I was addressing more the type of a death by 1000 cuts and how it is a very
frustrating experience on both sides. I personally don't have experience to
make a judgement either way on Lisp.

But your comment illustrates the general point I was making. You say that
there is no reason to hate Lisp.. It seems there is a perception that un-
informed and plain ignorant amateurs hate your favorite tool for no apparent
reason. However a death by a 1000 cuts occurs after someone has bought into
the technology and gave it a try. They invest time in it, but eventually it
doesn't work out. And that's the thing, there is no good _one_ reason why it
doesn't work out. It is a lot of small ones. The parens, lack of a single
comprehensive library package, the syntax, and so on. All silly stupid
reasons. It is pathetic to enumerate them and it is frustrating to hear them
enumerated and that's the reason I called this a nasty "death".

~~~
agentultra
I never said there was _no reason_ to hate Lisp. Just that the majority of
reasons that people give are not good ones. Hate is infectious and thrives on
ignorance to propagate. The fact that the 'hate page' is more than twice as
long as the 'love' page while 80% of the hate page is full of redundant
arguments about syntax just goes to show that most people making these
arguments really have no case to merit them.

I distinguish 'dislike' from 'hate' because the former is a more informed
position. If one knew enough about Lisp to understand it's merits, but still
couldn't produce useful software with it; they would have a reason to dislike
it. But it's hard to hate something that has real merit if you actually
understand it. You cannot hate the fact that compiled Lisp is pretty fast for
example. That's a good thing.

Lisp itself doesn't do much of anything poorly. It just may be that your
personal preferences prevent you from taking advantage of it. That's still not
a bad thing on Lisp's part.

So you see, while there may be a thousand little reasons a person can find
that keeps them from liking and using Lisp; it doesn't make Lisp itself a bad
language. Lisp has proven itself a great language. Just as C is a great
language, and Java, etc.

So I think someone should run through the hate page and compress it down to
the core arguments so people can get a better idea of what's going on.

------
sedachv
"For example, if a C programmer asked HowToSumFromOneToTenInLispOrScheme, he
might start thinking along the lines of... for (int i = 1; i <= 10; i++) ..."

The correct SmugLispWeenie reply is to say: "n(n+1)/2, now get out of here and
don't bother coming back until you've learned some math and have come up with
a real-world problem."

------
sgt
I wonder in which (if not all) ways this applies to Clojure.

~~~
ihodes
It's interesting; lots of the complaints I got to are in fact addressed by
Clojure.

Syntax: code is still data, but there is additional syntax (like {} for maps,
[] for vectors) that makes reading coding a bit easier; I don't particularly
thing Lisps are hard to read anyway, but it is nice.

Function names are less obscure; we have first and rest instead of car and
cdr, for instance.

I also hope we're a nice community to be around! I've certainly enjoyed my
stay so far.

~~~
KC8ZKF
FIRST and REST are from Common Lisp.

[http://www.lispworks.com/documentation/HyperSpec/Body/f_firs...](http://www.lispworks.com/documentation/HyperSpec/Body/f_firstc.htm)

[http://www.lispworks.com/documentation/HyperSpec/Body/f_rest...](http://www.lispworks.com/documentation/HyperSpec/Body/f_rest.htm)

~~~
nickik
yes but in CL you have "rules" when to use first/rest and when to use car/cdr.
A noob does not want to learn them.

------
julius_geezer
I don't hate Lisp, I rather like when I encounter it. The only actual work use
I've made of it was a command or two in Emacs Lisp years ago.

On the other hand, I'm tepid toward JScript and dislike VBScript. But
occasionally I have had to write something to run on Windows machines where I
could not install a preferred language. So one of the two it had to be.

I don't particularly like PHP--its support for closures and constructs such as
map aren't pretty. But it's might easy to configure and run on any given Linux
box. If the Lispers want to build and distribute mod_lisp RPMs, I'll be hapy
to take a look.

------
mahmud
c2 is where the LtU crowd goes to for relief, after a few drinks.

(with apologies to my IRL friends, and avid wikiers :-)

------
adlep
LISP is way over my head. The entire recursion based theme of LISP does not
click with me, and it is entirely my fault. I tried and I barely passed my
LISP class. It was though. I remember having problems writing even the
simplest code - like Fibonnaci in LISP... If you know how to code in LISP, you
surely must be an android.

~~~
gjm11
You don't have to write recursion-heavy code in Lisp. You can if you want to,
and it hurts less than doing the same in many other languages, but iteration
in Lisp works just fine too. (The Common Lisp LOOP macro basically gives you a
little embedded language just for expressing iteration. So does ITERATE, which
some people prefer but isn't in the standard.)

------
lelele
However, Common Lisp's LOOP really sucks. ITERATE fixes that: <http://common-
lisp.net/project/iterate/>

~~~
sedachv
I'm another person that likes loop more than iterate.

------
mnemonicsloth
Best sentence from the c2 Clojure Page:

"Is probably a HomoiconicLanguage"

<http://c2.com/cgi/wiki?ClojureLanguage>

