
If Lisp Is So Great (2003) - munchor
http://paulgraham.com/iflisp.html
======
ridiculous_fish
I think it would be valuable for other commenters to share why they did or did
not choose Lisp for their most recent project(s).

I chose Go for a recent project, and TypeScript for another. Both languages
make getting started very easy: they have straightforward installation, good
tooling, and a lot of support for when things go wrong.

I did not seriously consider LISP, and I think the main reason is that it's a
very confusing landscape. Google "how to install LISP" and you get a page like
[https://en.wikibooks.org/wiki/Common_Lisp/First_steps/Instal...](https://en.wikibooks.org/wiki/Common_Lisp/First_steps/Installation)
with half a dozen options. It's hard to choose and most of these do not look
promising. For example, Steel Bank Common Lisp is one I have heard of, but
their binaries are out of date and they use SourceForge (shiver). Arc is
another, but their installation instructions do not inspire confidence with
disclaimers like "don't use the latest version." My concern is I will spend
two weeks diving in before hitting some hard limitation, and I'll be stuck.

(Clojure is surely the best known modern LISP, but I do not want to depend on
the JVM.)

Speaking as an outsider, I think LISP would gain a lot more traction if its
community coalesced around a single implementation. (Sorry if that's a clichéd
argument). This would allow for investment in areas like documentation,
platform support, tooling, etc. The functional language community went through
this and the result was Haskell, which is excellent in all of those areas.

~~~
oskarth
There's no one lisp; there are many. Here are the top three:

Clojure:
[http://clojure.org/getting_started](http://clojure.org/getting_started)

Racket: [http://docs.racket-lang.org/getting-started/](http://docs.racket-
lang.org/getting-started/)

Common Lisp:
[https://www.quicklisp.org/beta/](https://www.quicklisp.org/beta/)

Lisp is a family of languages. All the dialects are good in their own way -
"standardization", if such a thing even makes sense, would be counter-
productive.

~~~
ridiculous_fish
The history of Haskell is described in this PDF:
[http://research.microsoft.com/en-
us/um/people/simonpj/papers...](http://research.microsoft.com/en-
us/um/people/simonpj/papers/history-of-haskell/history.pdf)

This paper describes the situation in the mid-1980s as a "lazy Tower of Babel"
with competing lazy-functional languages like Miranda, MLs, Orwell, Clean,
Ponder, each good in its own way, but none of them with critical mass. Thus
they decided to create Haskell as a new, common language. No doubt each
language designer felt that Haskell compromised on their particular vision,
but rallied around it anyways, resulting in a far more potent force for lazy
functional programming than ever could have been achieved working separately.

Why does this not describe LISP today? Honest question.

~~~
zodmaner
Common Lisp _IS_ the consolidation of various Lisp dialects that you've asked
about.

Back in the 70s and 80s there are numerous Lisp dialects (way, _way_ more then
there are today, since each dialects has their own sub-dialect and so forth),
and so Common Lisp was created back in the 80s (the work started in 1981 and
finished in 1994) to unified various Lisp dialects into one common language.

And Common Lisp accomplishes that objective, well mostly anyway. Soon(-ish)
most people, companies, and institutions ported their Lisp code base to Common
Lisp, and by the late 80's and early 90's, when you say Lisp most people will
(correctly) assume that you mean Common Lisp, not MacLisp or InterLisp, or
some earlier, long depreciated dialects.

You can read more about the nitty gritty details in the Evolution of Lisp
essay by Richard Gabriel here:
[http://www.dreamsongs.com/Essays.html](http://www.dreamsongs.com/Essays.html)

Now, about Scheme. Remember when I said that Common Lisp _mostly_ accomplishes
its objective of unifying various Lisp dialects? Yeah, basically the Scheme
community didn't like how Common Lisp turns out, so they decided to stick with
Scheme. And it is understandable why they feel this way, because despite
outward appearance, the two languages are very different, with Scheme focuses
on small (and mathematically elegant) core language, while Common Lisp, with
its focus on being practical, is a huge language with a standard library that
includes everything and a kitchen sink. Scheme also has a totally different
evaluation model compared to Common Lisp and its own macro system with
emphasis on hygienic. Not to mention that Scheme has its own standard, the
R*RS (now in its 6th revision, with 7th in the drafting process).

Now, the thing about Common Lisp is that it is very hard, if not downright
impossible, to change its standard. This means that it is not easy to make a
substantial changes to the language and has the wider community adopt it (and
we haven't even talk about changes that will break backward compatibility
here). This is one of the reason that Rich Hickey created Clojure as an
entirely new Lisp dialect (before this, he had implemented a Java FFI for
Common Lisp). Clojure has a new syntax that is far more consistent than Common
Lisp (which comes at the cost of breaking backward compatibility), as well as
many new and experimental features, such as immutability, asynchronous
operations, and the focus on functional programming style. All of these would
be very hard to introduce into Common Lisp without significant efforts and
time.

~~~
pmoriarty
_> Scheme focuses on small (and mathematically elegant) core language, while
Common Lisp, with its focus on being practical_

I don't think it's really fair to say _modern_ Schemes aren't focused on being
practical. Nor that they're small.

Take a look at Chicken or Racket, and you'll see that they have quite
substantial libraries and many features above and beyond the specs that make
them much more practical than the core Scheme spec alone.

Quite beside that, there's also the new R7RS[1] spec's "large" language is
just that: large. It's also focused on being practical. So I wouldn't say that
the traditional Scheme vs CL divisions in terms of size and practicality still
hold.

I would say that Scheme is more elegant than CL, and more modern, and less
crufty. Unfortunately, there are still far more programmers using CL than
Scheme. Hopefully with Emacs' move to Guile that will change.

That said, I still love CL, and would far rather use it than any other
language, except Scheme.

[1] - [http://trac.sacrideo.us/wg/raw-
attachment/wiki/WikiStart/r7r...](http://trac.sacrideo.us/wg/raw-
attachment/wiki/WikiStart/r7rs.pdf)

------
lolo_
Sadly this article (IMO) is not one of PG's better ones, and I am quite
surprised by the lack of self-awareness around it - it boils down to 'if
you're clever, you'll use and appreciate this language', when actually there
are practical reasons as to why lisp is not so popular.

It actually feels really closed-minded - like you've walked into a conceited
professor's office and told him you have doubts about one of his ideas and
he's looked down his glasses at you and talked about how most people prefer
McDonalds to amuse-bouche at Pierre Gagnaire in Paris.

How about considering whether there are reasons other than 'it looks foreign
so lesser programmers don't bother with it'? If you google around you find
there are plenty of people who suggest practical reasons (too many fragmented
implementations, hard to debug, etc.) as to why it's not caught on, and in
fact a lisp like clojure seems like an attempt to learn lessons about what
might work better or not. But no, we have these patronising proclamations and
the article is over.

Don't get me wrong, I'm not anti-lisp per se, but I've come to think as I've
seen more of the programming world (and worked with good developers as well as
bad) that language has less of an impact on a project than I previously
thought.

What I hate is the smug attitude a lot of lispers have, as if it's some
incredible magical secret that only smart people can understand and if only
we'd all see the light this world of shit code would turn upside down. It's
hard to prove anything in the complicated world of programming, and I just
don't buy this idea that it's magically better.

We should admit the subjective nature of these things, admit that it's really
hard to tell what kind of a difference a language makes and instead of smug
patronising talk of how wonderful language X is, point out what is unique
about the language and stay humble.

I much prefer PG's more practical detail-orientated explorations of lisp and
what makes it powerful in the first place to this one.

~~~
isxek
Thanks. This got me started on studying Racket, though:

[http://practicaltypography.com/why-racket-why-
lisp.html](http://practicaltypography.com/why-racket-why-lisp.html)

~~~
zodmaner
Racket is an elegant and powerful language, you wouldn't regret learning it.

------
paulsutter
I have a litmus question about this assertion that programming in language X
is the secret to writing great software (quote from another pg essay[1]):

> Our hypothesis was that if we wrote our software in Lisp, we'd be able to
> get features done faster than our competitors, and also to do things in our
> software that they couldn't... What were the results of this experiment?
> Somewhat surprisingly, it worked... We eventually had many competitors, on
> the order of twenty to thirty of them, but none of their software could
> compete with ours... It must have seemed to our competitors that we had some
> kind of secret weapon... We were just able to develop software faster than
> anyone thought possible.

Here's a better experiment:

\- Take two teams: one with great programmers, and one with mediocre
programmers.

\- Force them to swap toolsets.

Question, which team will outperform? If language is the secret, the mediocre
team should outperform the talented team.

But that's preposterous. Great developers write good software fast. Bad
developers do otherwise. All developers work best in their favorite tools.
Because they are adept using their favorite tools.

[1] [http://www.paulgraham.com/avg.html](http://www.paulgraham.com/avg.html)

~~~
sklogic
Great team with mediocre tools would work many times slower (and will be more
likely to quit due to boredom). You have to compare equivalent teams instead.

~~~
mamon
Great team with mediocre tools would come up with their own tools to make up
for the limitations of the basic ones. After wasting some time to do that they
would then proceed as great team is supposed to :)

~~~
pka
So they would write a Haskell compiler in Java/Go/Python first? :)

------
raspasov
To answer some of the people in the thread that have asked why you might want
to choose a lisp, here's an answer.

I have chosen a lisp (Clojure) because:

\- Clojure allows me to write code that is robust, fast, and simple

\- because it's simple, most Clojure code is easy to reason about, now,
tomorrow and six months from now

\- focus on the data (JSON, html parsing, whatever) and the transformation of
it, which is arguably what we do most of the time in modern backend and
frontend (React-based) applications

\- pervasive and strongly encouraged immutability, managed concurrency,
discouraged callback hell, etc which makes it hard to write bad code in the
first place

\- I can change functional+dynamic+immutable code faster than any other code,
which allows faster experimentation and iteration on features

\- it works very well for both backend services (Clojure/JVM), and browser
applications (ClojureScript/Google Closure compiler), with the language
staying 97% the same

------
Ygg2
I think Lisp's power is its greatest weakness.

It's easy to make a Lisp, but hard to make them compatible. So you get one
language with a billion non-communicating dialects.

~~~
sklogic
Compatibility is vastly overrated.

------
hasenj
I read somewhere recently that YC uses ruby (or something like that) for their
internal software, not lisp.

EDIT: found the link

[https://jobs.lever.co/ycombinator/8703c1d9-af67-4826-90e4-74...](https://jobs.lever.co/ycombinator/8703c1d9-af67-4826-90e4-74b5067c4dd7)

> The YC internal software is mostly written in Ruby on Rails. We also use:
> JavaScript, React, AWS, and PostgreSQL. Some experience developing web apps
> would be helpful, but we don't care if you've used Rails before.

~~~
copperx
Something like that would be Python? A link would be great.

~~~
hasenj
Edited my comment with the link

------
joesmo
I definitely agree that the most popular languages, tools, frameworks,
paradigms, etc. are by definition not the best. These are popular because
they're used by average programmers. They get the job done, though not in the
best way, and are popular because of that (see for example Javascript).

I found that Clojure (my first Lisp) was the easiest language to pick up that
I've ever learned. Partly, that's because I've been doing this a long time,
but I also think it speaks volumes to the simplicity of Lisps and Clojure in
particular. I have no doubt that I could teach it to programmers and non-
programmers alike rather quickly and I really wish it was at least studied, if
not used, more so that people would have more experience with functional
concepts. Even just a week or two of studying it is quite beneficial and a
good contrast to typical OO languages.

------
i336_
Apparently the "toy benchmark shootout" thingy the article links to has been
modernized to being utterly unusable.

Here's what I think the article was linking to:
[http://web.archive.org/web/20051202060638/http://shootout.al...](http://web.archive.org/web/20051202060638/http://shootout.alioth.debian.org/benchmark.php?test=nestedloop&lang=all&sort=cpu)

This is also potentially relevant (the snapshot is noninteractive):
[http://web.archive.org/web/20070216224601/http://shootout.al...](http://web.archive.org/web/20070216224601/http://shootout.alioth.debian.org/gp4/benchmark.php?test=all&lang=all)

------
codyguy
This question would be on the lines of :

* If you are so smart why aren't you so rich

* If your product is so great, why aren't you the market leader already

~~~
Nicolas0682
Good question. For Paul Graham it certainly worked.

By combining a great team of competant people, a small startup environement
were you can concentrate on getting thing done and by using powerfull tools
they made their software, managed to have it evolving faster than their
competitor and then sold it to Yahoo.

Ironically since the tool has been brought back by Yahoo its growth stopped
and nobody know of it anymore. Is it because of the different people working
on it? Is it because they had now a different management structured that cared
more of politics? Or was it because they decided to recode everything in C++ ?

To me that's likely a combination of all the things.

That's the key point. A great programming language and echosystem is a great
start. But that's not enough. You also need pragmatic management that make
decision for the good of the company and not for politics and you need to have
employees that care of their job.

At the end, you should know if you are in a model of small efficiant teams or
huge average teams. Most company start with the former and end up in the later
as they grow. Ultimately that why the next start up has a possibility to beat
them. You would never be able to beat microsoft if everybody inside had a
startuper mind-set. They would own the world.

That why people fear google so much. I'am pretty sure they have lot of
politics and are already more in the later phase than the former but they at
least managed to keep bright people working for them.

------
gaius
I still hope that Thrift will make the language you choose irrelevant, so long
as it has bindings. Then we will all be free.

------
personjerry
So, what about Lisp makes it great? I learned some Lisp in a CS course a while
ago, and while it certainly seemed interesting, I didn't feel anything special
(perhaps I ought to spend more time with it?). Could a pro give me a short
list of the biggest advantages, compared to C or Python?

~~~
Synaesthesia
The major advantages are extreme modularity and conciseness - you can write
much shorter expressions than competing languages, like C, Python, Java etc.
Macros are another big feature, which allow you to generate code easily and
lastly the ease with which you can write self-modifying code (Homoiconic code)
is often praised.

Here are some more good answers to that question in a Stackexchange thread
[http://programmers.stackexchange.com/questions/9320/why-
is-l...](http://programmers.stackexchange.com/questions/9320/why-is-lisp-
useful).

edit: another one - [http://stackoverflow.com/questions/2036244/whats-so-
great-ab...](http://stackoverflow.com/questions/2036244/whats-so-great-about-
lisp)

~~~
progman
> you can write much shorter expressions than competing languages, like C,
> Python, Java etc.

Exactly. For instance, consider Clojure, PicoLisp, Racket and Wolfram in
[http://rosettacode.org/wiki/24_game/Solve](http://rosettacode.org/wiki/24_game/Solve).

------
ane
Lisp isn't just a concept, it's also a family of implementations. The two
significant branches are Scheme and Common Lisp. The only thing they have in
common is using parentheses - they're about as different from each other as
JavaScript and C.

Scheme is more functional programming oriented, Common Lisp is less so. Scheme
is very minimalist, it's most recent standard contains only about 20 syntax
definitions! Unfortunately this transformed Scheme into a concept from an
implementation. Compare this to CL, which has just about everything and the
kitchen sink, and is more of a "concrete" language.

To choose a Lisp is to choose an implementation. I'd recommend playing with
all of them. Common Lisp, a Scheme (CHICKEN or Guile), or the "recent" ones
like Clojure and Racket. Racket is very much a Scheme - it used to be called
PLT Scheme - and has a bunch of PLT superstars building really cool stuff with
it.

Clojure, the JVM-based Lisp, has more in common with Common Lisp than any
other, but embodies a strong philosophy about identity and value. It has a lot
of common with Haskell in that regard, supporting immutable data structures
and STM right out of the box. It also has really cool ideas like transients
[1], transducers [2] and protocols [3], features which have since crept into
other languages.

Clojure is probably the most popular right now, and its ecosystem is growing
every day, and can be used for building serious stuff. This doesn't mean you
can't build cool stuff with other Lisps! CHICKEN Scheme has a great package
ecosystem, so does Racket, Guile lags behind, and for Common Lisp there's a
recent "State of the Ecosystem" article[4] that summarizes its ecosystem.

 _" Lisp is worth learning for the profound enlightenment experience you will
have when you finally get it; that experience will make you a better
programmer for the rest of your days, even if you never actually use Lisp
itself a lot."_

\-- Eric S. Raymond

[1] [http://clojure.org/transients](http://clojure.org/transients)

[2] [http://clojure.org/transducers](http://clojure.org/transducers)

[3] [http://clojure.org/protocols](http://clojure.org/protocols)

[4] [http://eudoxia.me/article/common-lisp-
sotu-2015/](http://eudoxia.me/article/common-lisp-sotu-2015/)

------
Dolores12
Ok lets say i want to program a webcrawler in lisp & c# and cant figure out
how to do it. I simple go and google it, right? how to crawl web page in lisp
- returns unrelated websites. i still have no clue how to do it. how to crawl
web page in c# - second link returns me a solution to my question.

So why would i waste my time if i can get things done faster in more popular
programming languages? English or Esperanto?

~~~
dman
Two roads diverged in a yellow wood,

And sorry I could not travel both

And be one traveler, long I stood

And looked down one as far as I could

To where it bent in the undergrowth;

... ...

I shall be telling this with a sigh

Somewhere ages and ages hence:

Two roads diverged in a wood, and I—

I took the one less traveled by,

And that has made all the difference.

~~~
ubernostrum
This poem was actually written satirically by Frost about going for walks with
a friend who always complained afterward that they should have taken some
other route and acted as if it would have been significantly better... when in
reality it would have made no real difference:

 _Frost 's biographer Lawrance Thompson is cited as saying that the poem's
narrator is "one who habitually wastes energy in regretting any choice made:
belatedly but wistfully he sighs over the attractive alternative rejected."
According to the Thompson biography, Robert Frost: The Years of Triumph
(1971), in his introduction in readings to the public, Frost would say that
the speaker was based on his friend Edward Thomas. In Frost’s words, Thomas
was "a person who, whichever road he went, would be sorry he didn’t go the
other."_

~~~
dietrichepp
I think that makes the poem especially apt, considering how some programmers
fret over language choice.

