
The Failure of Lisp? A Reply To Brandon Werner - lackbeard
http://danweinreb.org/blog/the-failure-of-lisp-a-reply-to-brandon-werner
======
jlouis
Lisp (any lisp, be it lisp-1 or lisp-2) are currently fighting a fight on
multiple fronts. From one side, each iteration of Python or Ruby gains new
ground as they incorporate more and more lisp-concepts, while being "Visually
friendly" (ie, with common syntax). They also have the ability to lure many
more users from, say Java or C#.

On the other side, you have any language with type theory governing the
language design: haskell, ML, etc. These have long since gobbled up most
people interested in type theory and even these are loosing out to the new
batch of languages with richer type zoos.

Lisp is not a failure and it has had more influence than people think.
However, I think Lisp has played its major part like IBM has played theirs.

~~~
kylec
While I hear many people complaining about the "awkward" and "hard-to-read"
syntax, it's rare to hear someone compliment the syntax of lisp. I am a big
fan of the Lisp syntax because it's so simple and consistent - probably a
relic of its roots in lambda calculus. Not having to worry about operator
precedence is a huge bonus in itself - I don't know why on one hand people
cling to PEMDAS, logic, assignment, etc having a complicated hierarchy of
precedence and on the other reject lisp because it's too "foreign".

~~~
silentbicycle
I agree. I wish ML used s-expressions.

Also, you might like this presentation, "The Swine Before Perl" by Shriram
Krishnamurthi (of PLT). It's a great thing to show people who wonder how you
could think Lisp has a _good_ syntax:
[http://www.cs.brown.edu/~sk/Publications/Talks/SwineBeforePe...](http://www.cs.brown.edu/~sk/Publications/Talks/SwineBeforePerl/)

(Also: SK's book is great.)

~~~
blasdel
ML and it's successors do not want for s-exprs.

They force an inappropriate fundamental data type on everything, and are only
of benefit if you want to fiddle with the insides of extant functions.

Use composition like a real FPer. Learn that there's so much more to data than
lists + atoms.

~~~
silentbicycle
> They force an inappropriate fundamental data type on everything, and are
> only of benefit if you want to fiddle with the insides of extant functions.

Please explain.

(And I know composition, etc. I also use Haskell and Forth.)

~~~
jlouis
I think what is meant is that the list is the primary data structure for
everything in lisps. Fortunately, it is not the only data structure in lisps.
I dislike constructs where eg. a graph edge is built as:

'(GRAPH-EDGE <source-vertex> <target-vertex>)

whereas in ML you would write

type edge = { source: Vertex.t; target: Vertex.t }

which is not a list, but an entirely different representation. In Common Lisp
the representation could of course be a CLOS object or a DEFSTRUCT (I think,
my CL-fu is definitely not that good).

As for the composition, lisps are lacking (nice) currying which is one of the
basic building blocks when constructing combinator-libraries.

~~~
dlweinreb
It's true that earlier Lisp dialects had trouble. But in Common Lisp, you can
do currying just fine. At work (ITA Software), it's part of our standard
utility library.

------
gruseom
Such a respectful reply. To judge by his writing, Weinreb is a genuinely nice
man. I'm glad that he has taken on a (semi-) public role as Lisp advocate.

I'm a recent (last 3 years) adopter of Common Lisp who works in it every day.
To me Lisp is hardly a failure, it's a secret weapon. For example, a couple of
weeks ago I had occasion to take a complex chunk of CL code and make it
compile into Javascript as well (I need it to run both on the server and in
the browser, under different circumstances). The point isn't that I _needed_ ,
say, Lisp macros to do this. The point is that I was able to do it pretty
_easily_. As a working programmer, I'm surprised by how often something that
feels like it'll be scary and hard turns out to be pretty easy in CL. In fact
I often spend more time worrying about it than I do coding it (which makes me
wonder how long it will take before certain habits that come from experience
in less productive environments die off).

This isn't the sort of thing you can really analyze on the level of language
features. I find that a lot of the discourse around language comparison is the
activity of researchers and hobbyists (for want of a better term) who aren't
immediately concerned with building major systems. They like to explore many
different things and the programming tasks they take on tend to be conducive
to that - coding exercises and such. That's great, but not the same
perspective as when you throw yourself into making one big system over months
or years. To the first sort of person, the various Lisps and startup
annoyances and incompatibilities constitute a huge barrier, enough to say "why
bother" and move on. To me they were an investment that paid off relatively
quickly and has since produced big gains. (I mean technically. We'll see if
they cross over economically.)

Lisp isn't going to have a major resurgence on language grounds alone. It's
too old for that, and too suboptimal for blog posts. What would, though, make
a big difference is seeing more successful products made with it. That may
sound odd as there have been few so far, but that's where I think the untapped
potential of Lisp is. And if that ever happens, an ecosystem might develop
that has fewer of the dysfunctional aspects of the past. Successful companies
that use Lisp would fund open source development, and so on.

~~~
dlweinreb
Thank you for the kind words!

I don't think that Brandon Werner said that Lisp was a failure as a language.
As I read it, he's saying that Lisp has failed to capture a lot of new users,
get very popular, and so on.

I agree with you that a lot of the really big advantages of Lisp show up
better in large systems than in small coding exercises.

There have actually been lots of successful products made with Lisp. People
just don't say so, sometimes because Lisp is unpopular and sometimes because
it's just not important. InspireData is a great product, but there's no need
for anyone to know what language it's in: in fact, it's in the LispWorks
implementation of Common Lisp.

For links to success stories, see my survey paper at <http://common-
lisp.net/~dlw/LispSurvey.html> and see the "Success Stories" section.

------
jwilliams
Lisp is the second oldest high level language, having barely been pipped by
FORTRAN... and it's still around, and under active development. Long way from
a failure.

Equally, with that kind of a trajectory and history, you'd also have to
predict Lisp isn't going anywhere soon.

If anything, the rising interest and competition in functional languages is
pushing Lisp back into the spotlight.

------
pavelludiq
I don't know CL, but from the subset of scheme that i know, i cant imagine how
can this language fail. It just feels too good and the code is so beautiful. I
could say for certain that scheme has made me into a better programmer.

~~~
silentbicycle
Common Lisp and (especially!) Scheme are really elegant languages, sure, but
there's really something to be said for being able to install the one clear
Python implementation* and getting a huge standard library with lots of
documentation and a large community, upfront, versus trying to figure out
whether you should set up SBCL or CLISP or PLT or Chicken or ..., then finding
there are several libraries for what you're trying to do, but you're not sure
they're compatible with the compiler/interpreter you're using, etc. And then,
what editor do you use? ("What's this SLIME thing about?") And this, that, and
the other thing. That is a _lot_ to figure out, all at once and upfront,
before you can try it out. Making it really hard for curious people to play
around with Lisp means that few people will see its potential.

All of the above could just as well apply to Ruby or even Haskell. I think
Python, in particular, has been really carefully designed to give a good first
impression, though. I don't know if that was deliberate or not, but it's
brilliant. (I know some people balk at the indentation-based syntax, but I bet
many people coming from e.g. a Perl or C++ background think, "Whoa, this looks
really clean." "Executable pseudocode.") Lisp doesn't really seem to focus on
making a good first impression. (On the other hand, OCaml just says, "Hello!"
and immediately backhands you. It makes up for it once you understand the type
system, but I'm not at all surprised the OCaml community is small.)

Stuff like Lisp in a Box helps a lot, but it wouldn't hurt to have a link to
it in 300-pixel-tall burning letters at the top of lisp.org, you know? You
can't even go directly to a download page for any implementation from
lisp.org. (When you click the download link at the top of Haskell.org, it
takes you right to GHC's download page.)

I've also frequently heard the Lisp community can be rude or off-putting, but
I haven't experienced this personally. I could see them being a bit gruff and
frustrated about answering a lot of the same questions over and over again,
though, and seeing languages like Python and Ruby getting so much more
attention than Lisp can be heartbreaking.

So, basically: Marketing.

* I know about Stackless, etc., but which does _python.org_ point you to? QED.

~~~
dlweinreb
Yes, lisp.org needs to be (and will be) vastly improved. We definitely need
the equivalent of a CPAN for Lisp, and several of us are working on producing
such a thing. You're quite about marketing!

As for multiple implementations: CPython, Jython, IronPython, Stackless
Python, PyPy. What editor do you use? Gnu Emacs with Slime; or, some of the
commercial Lisp implementations come with IDE's; and there's work being done
("curl") to make Eclipse work well with Common Lisp. Java has several IDE's,
such as IntelliJ and Eclipse. For Python, what I'm told by the Python experts
I know is that they just don't use any IDE.

But much of what you're saying above is very much to the point. The comments
on my blog posting go into these issues more.

~~~
silentbicycle
> We definitely need the equivalent of a CPAN for Lisp

Agreed! I like the Eggs repository for Chicken
(<http://chicken.wiki.br/Eggs%20Unlimited%203>), but individual Scheme
implementations just aren't compatible enough for such things to really
benefit them _all_ \-- I'm pretty sure the lack of a module system in the core
for R5RS is to blame. There's one in R6RS, but I hope it's not too little, too
late.

------
gibsonf1
Some may consider Lisp a failure of a language, but I sure am glad my startup
is written in Lisp! The issue of syntax baffles me, because in recently
learning Javascript, the essential area of bugs for me were almost all syntax
related. I never have to worry about syntax in lisp as its either ( or ).
There are no ; or } or { or , etc to worry about what goes where when.

The logical structure reveals itself so clearly in the form of indentation so
that the parenthesis become transparent for me. Having emacs slime automate
the indenting is of course essential in enabling a clear focus on the function
of the code instead of spending time thinking about the syntax.

------
lallysingh
Lisp's biggest problem is the simple fact that most other languages already
ship with most nonwindows boxes. _Successful_Lisp_ is a good book (amongst
others), but what do you type the code into?

Until today, I hadn't heard of SBCL. I've been fiddling in e-lisp, which is a
tragedy of its own sorts. The only mention of SBCL in "google:lisp linux" is
an ad. I don't think I'm the only one still afraid of a $5k entrance fee for
lisp.

~~~
dlweinreb
Soon, lisp.org will be redone to make it easy to find good free Lisp
implementations. Meanwhile, check out my survey paper at <http://common-
lisp.net/~dlw/LispSurvey.html>.

------
13ren
_"the community is judgmental and unfriendly to newcomers and thorny and un-
inspiring."_

Brandon's reply _agrees with this criticism_ , because "I have heard this same
criticism from other people than you, and at this point I assume it must
really be true."

The comments here focus on lisp. Lisp isn't the problem.

------
known
In my college days I was very interested in AI and learned Prolog and Lisp.

