I like Lisp. I really do. I learned it in college about fifteen
years ago and during my PhD, I was happily hacking emacs Lisp on a regular basis.
When the OOP trend hit, I was ecstatic to be able to combine the power
of Lisp and objects in Common Lisp and also some other variants, such as Scheme, CAML, or Haskell. They’re all fascinating tools for the mind and they
definitely change the way you look at programming.
That being said, there is something I don’t quite like about Lisp: its
Lisp is a language that never really made it in the mainstream, and this
failure has caused a profound trauma in its followers.
The Lisp community
suffers from a severe case of "underdogness" which manifests itself as acute
short-sightedness, persistent bitterness and ravaging delusion, which I also like to refer to as the "Luke
Skywalker syndrome", where you feel you are part of the resistance against
a bigger and ruthless power (I once suffered from this syndrome when
I was the proud — too proud — owner of an Amiga).
Lisp fanatics are an amusing crowd, really, and what prompted this post is precisely
the amusement that this introduction to Haskell procured me.
This page starts by giving an implementation of Quick Sort in C and then in Haskell:
qsort  =  qsort (x:xs) = qsort elts_lt_x ++ [x] ++ qsort elts_greq_x where elts_lt_x = [y | y <- xs, y < x] elts_greq_x = [y | y <- xs, y >= x]
which is then described as:
Functional programs are often easier to understand. You should be able
to understand the program without any previous knowledge of either Haskell or
quicksort. The same certainly cannot be said of the C program.
What a gem.
I also liked:
In particular, strong typing means no core dumps!
The assumption here being that Haskell is strongly typed, a claim that
would be enough to start an all-out flamewar on comp.lang.* that lasts for
months, but the core dump
argument really takes the cake. Are you convinced to convert to
Lisp users do have a sense of humor, though, so make sure you visit
Paul Graham’s collection of Lisp