
Lisp Is Too Powerful - felipebueno
http://c2.com/cgi/wiki?LispIsTooPowerful
======
raganwald
This old argument. I won't say a thing about Lisp. Let's talk about Ruby. For
those of you who were using Ruby in 2005 when Rails was released. Are there
any of these arguments that you haven't heard at least _once_ in the last
eight years about Ruby? That it's too powerful, that programmers make their
own idiosyncratic worlds, that programs are too complicated to understand, &c.
&c.

Yet, somehow, There is tons of working Ruby code in production and people have
found a way to harness its power. People are awfully clever, I very much doubt
that any serious language (i.e. a language not designed to confuse) can't be
whipped into shape by a team of reasonable people who are motivated to
succeed.

The "failure" of Lisp has a very simple explanation, so simple that people
gloss over it. Every successful language began as the scripting language of
some system that was itself exploding in popularity.

To be a hit, a language must arrive in the mass market's consciousness in
tandem with its "platform." Objective C failed until the iPhone was a hit. C
was a hit with Unix and then Windows. Ruby was a hit when Rails was a hit.

Lisp was the scripting language of Lisp machines. When the "AI Winter" hit
Lisp machines, it hit Lisp. It never became the scripting language of
something else that was exploding in popularity.

Today JavaScript is the scripting language of browsers, so it is a hit, and it
doesn't matter whether its first-class functions are elegant (they are),
whether its semantics have stupid corner cases (they do), or whether its
inheritance model is obscure (prototypes!?).

Just show me something exploding in popularity, and I'll show you a successful
programming language.

UPDATE:

I see folks are arguing about what colour to paint the phrase "Scripting
Language." Must a scripting language be interpreted? Is Java interpreted? What
about JIT techniques for JavaScript? When we transpile CoffeeScript to
JavaScript, what is going on? I have a CPU that executes microcode. Is ASM for
this CPU really an interpreted language?

All good stuff. By the way, Lisp was originally interpreted, compilers didn't
come along until later. So... Was it a scripting language until it was
"compiled?"

Have fun, but please remember to leave room in the shed for me to park my
tandem.

~~~
lispm
COBOL, Fortran, C++, Ada... were the scripting languages of what exactly?

If I were staying in your argument, then Lisp was the language of symbolic AI.
The language where things like symbolic mathematics (Macsyma, Reduce, ...),
planners, theorem provers, natural language understanding, reasoning systems,
expert systems, knowledge-based systems (Cyc, ...) were explored and first
tried to commercialize (mid 80s). Symbolic AI funding went away with the cold
war ending...

Lisp was actually invented and designed for this. John McCarthy was designing
Lisp as a vehicle for (his) AI research.

There might still be a lot of Lisp users. Even among AI researchers (and
related domains) there are many using Lisp tools which you probably have never
heard of - like ACL2 (a theorem prover), PVS (a theorem prover used at NASA),
ACT-R (a cognitive architecture with more publications written about then you
can ever read). The usage of Lisp may even be constant in these domains. There
was an explosion of programming in general. Outside these domains Lisp never
really participated in this explosion (with a few exceptions like Lisp in
Autocad, Lisp in Emacs, ...).

But should it? Lisp's almost unbounded flexibility is obviously not needed by
the average programmer. It is actually a something which makes a bad
programmer worse.

'Lisp Machines' were just one development/deployment platform - 10000 sold in
a decade. Lisp was used before Lisp Machines and after Lisp Machines.

> It never became the scripting language of something else that was exploding
> in popularity.

Autocad sold millions of copies and is still widely used today. Several
Autocad 'clones' support the use of Lisp for CAD scripting.

~~~
jimbokun
"COBOL, Fortran, C++, Ada... were the scripting languages of what exactly?"

Isn't Ada the scripting language of the U.S. Department of Defense? As far as
I know, most real world Ada usage is in DoD funded projects.

C++ won the battle over Objective-C to become C's successor for many
applications, so fills a similar ecological niche.

First sentence from History section of Fortran Wikipedia page:

"In late 1953, John W. Backus submitted a proposal to his superiors at IBM to
develop a more practical alternative to assembly language for programming
their IBM 704 mainframe computer."

So Fortran was the scripting language of the IBM 704.

COBOL's Wikipedia page indicates it was championed by a committee of all the
major computer industry players of its day, making it the Java of its time. So
COBOL and Java may be exceptions to this "scripting language of..." rule, and
instances of the "successful language created by a committee" rule. (Common
Lisp, of course, being an example of "unsuccessful languages created by a
committee".)

~~~
DigitalJack
I think you misunderstand scripting here. Scripting languages are interpreted,
and can be quite a bit simpler to implement and code in than compiled
languages.

Ada, C++, et al., are compiled languages.

~~~
mst
The "scripting language of" argument is normally presented with the first
example of C and UNIX - scripting is used here to describe the purpose it's
being used for, not the nature of the language itself.

------
pilgrim689
The original post is right: Lisp by itself is an incredibly powerful yet
incredibly basic language. It's a functional Assembly for declarative DSLs.
The most talked about Lisp nowadays is arguably Clojure, and this is probably
so because Clojure provides much more built-ins and libraries out-of-the-box
than other Lisps, where you'd have to build these things yourself. At the end
of the day, we just want to call "solveMyProblems()", commit that 1 function
call, and move on to our next project. The lower-level a language is, the
further away from that goal it is, and the less reasons there are to use it.

------
api
I suspect LISP is too unstructured for its power. It's very hard to scale
something to more than one programmer or to a large size in a completely free-
form dynamic language. It's easy to blow off other peoples' feet, and totally
dynamic languages with many contributors to a project often yield an
unmaintainable rats' nest of mixed metaphors and hacks.

Java is one of the most successful languages for massive projects because it
imposes a set of common idioms and semantics. Look at Eclipse... an absolute
monster but a living, breathing, and pretty darn successful one.

I can't imagine Eclipse in Ruby or JavaScript, let alone LISP... not with the
number of contributors it has. It would melt into a puddle of slag not unlike
the "corium" that forms at the bottom of a melted-down nuclear reactor.

For those dismissing this as FUD and ignorance: LISP, despite its power, isn't
really used for much. I think there _has to be_ a reason for that, and I don't
think "everyone is dumber than me" is a valid reason. There are tons of
outstanding programmers, and the majority of them do not choose to code real-
world stuff in LISP.

I suspect Ruby, which is fairly powerful but not as freeform or succinct as
LISP, is more successful because it has more structure around its power. It
seems to have enough structure to make large long-lived code-bases possible in
the "real world." (But like I said I'm still skeptical that you could write
Eclipse in Ruby.)

The question is: would it be possible to build enough structure _or tooling_
around LISP to fix this problem? Could something like Light Table with deeper
refactoring and visualization tools deliver a workable LISP environment for
modern large applications? I know there were things done in the past during
the "80s AI era" that might bear re-examination and resurrection.

~~~
btilly
You say it like it is essential that we scale to lots of programmers up front.

The problem is that there is an organizational barrier. It is easy to have
teams of under 8 programmers. It is doable to scale teams of 20+ programmers.
But if you're between those numbers, small team dynamics fall apart horribly,
and large team organization leaves you with less productivity than the small
team.

For a small company, the cost jump from 8 to 20 programmers is pretty
significant. Therefore it is worth considering the strategy of getting the
most out of your existing programmers and not trying to cross that chasm. If
you succeed, you eventually will have to face the scaling problem. But success
tends to take care of itself.

~~~
ww520
I think GP meant the number of people touching the software over its lifetime,
not necessary at the same time in one location like in a company. e.g. Eclipse
must have hundreds if not thousands of contributors, loosely networked and
hardly seen each other, contributing over a long period of time. Yet they are
able to understand each other's code and build on top of each other. The
readability of a language is a must to foster this kind of cooperation. Java
is a very readable language and the knowledge in the code can be easier shared
among developers.

------
agentultra
This is just a giant page of FUD.

Every language has flaws and using languages effectively means knowing what
those flaws are and how they affect your program's processes. Does Lisp code
produce unmaintainable masses of code? Perhaps. Ever read the IOCCC entries?
Or pull apart exactly what a given Ruby script is actually doing? Yet people
write good software using these languages all of the time and the world hasn't
blown up yet.

~~~
mordae
Not really, it's just C2 being C2. You can often see a lot of conflicting
opinions on those pages, but the arguments tend to be solid. Try reading these
two:

<http://c2.com/cgi/wiki?WhyWeLoveLisp> <http://c2.com/cgi/wiki?WhyWeHateLisp>

------
shared4you
The page is down for me, so Google cached:
[http://webcache.googleusercontent.com/search?q=cache:c2.com/...](http://webcache.googleusercontent.com/search?q=cache:c2.com/cgi/wiki?LispIsTooPowerful)

~~~
nkozyra
Webserver clearly not written in Lisp.

------
hrish2006
Lisp is perhaps the most powerful language there is. But no language is 'too
powerful' considering the software that is being built today. It has not
enjoyed commercial success because it gained reputation as an inefficient
language and the average programmer cannot become proficient in it unless he
has a certain amount of discipline and learning he is prepared to invest. C
and C++ are much easier to learn and are taught more in colleges. So the
reason lisp isn't popular is because people are not learning it. And even
those who learn it have less opportunities to use it because of the C, C++ and
Java legacy.

~~~
jeffdavis
It seems that you are cherry-picking. Lots of "inefficient" languages that
were never taught in schools have gained incredible ground -- consider python,
ruby, perl, and PHP.

~~~
hrish2006
On the contrary, all of those are being taught in schools python is now being
taught at introductory classes in MIT, Cal and Stanford to name some. Ruby and
PHP are taught too. At lest in grad school. Don't forget the private turoring
and certification programs you can enroll in. I have not seen a single
certification course that involves Lisp. Also, consider the ages of those
languages. Lisp has been around for more than 50 years now. The others are not
even half its age.

------
zwieback
Lisp is the most powerful language in the world - as witnessed by its power to
cloud the minds of otherwise intelligent and articulate engineers and
scientists.

------
officemonkey
13 years ago I spent a LOT of time on C2.com. Every time I see one of those
pages I have flashbacks.

~~~
felipebueno
I didn't know it yet. The content is very good.

------
Bjoern
<http://imgs.xkcd.com/comics/lisp.jpg>

<3 Lisp

~~~
saintx
<http://xkcd.com/312/>

Always makes me smile.

~~~
chimeracoder
I prefer thinking of myself as a Lisp warrior, valiantly carrying on the good
fight of my predecessors: <http://xkcd.com/297/>

~~~
saintx
May the s-notation be with you.

------
nvk
Cached Article here:
[http://webcache.googleusercontent.com/search?q=cache:pfmf4-8...](http://webcache.googleusercontent.com/search?q=cache:pfmf4-8kdAAJ:c2.com/cgi/wiki%3FLispIsTooPowerful+&cd=1&hl=en&ct=clnk)

------
jeffdavis
What is the definition of a "powerful" language?

It sounds to me like arbitrarily taking a word with good connotations to mean
something that is convenient for promoting what you're interested in;
regardless of the literal meaning.

------
jbowles
Things are too complicated. There is too much boilerplate. Software is hard.

------
felipebueno
Here is a nice 1986 MIT lecture on Lisp given by... Harrison Ford? :) -
<http://www.youtube.com/watch?v=2Op3QLzMgSY>

------
hiskennyness
"But I have yet to see a good demonstration that Lisp significantly simplifies
things beyond what other languages can do... It only slightly simplifies
things."

The circularity is impressive.

------
michaelochurch
_Lisp_ is not a problem. Lisp is fine. So are Scala, Ocaml, and Haskell, under
most use patterns. Python's not perfect, but I'll gladly use that. It works.
Actually, I like Clojure better than CL, but that's irrelevant. I had one
experience of being burned by "Lisp's power". I was in a company where I had
to work with a programmer who used Lisp in ways the rest of us found to be
irresponsible (poor documentation).

He actually wasn't a bad programmer. He was actually a pretty good one, but
management had been riding him with unreasonable feature requests and
ridiculous deadlines, so no one ever got to do anything right in that company.
My code was better, not because I'm inherently better but because I fought
back and simply padded the shit out of estimates so I _knew_ I'd have the time
to do things right.

These problems that get blamed on languages are usually the result of terrible
management.

Even bad code is not pure evil. Bad code is just logic, poorly fashioned and
presented, often because of shitty business practices rather than poor
programmers. The evil is the manager who _forces you to use_ bad code (instead
of letting you replace it) because "we can't afford" doing things right, even
though you're in a rich company that pays managers extremely well. That's the
enemy. Let's stop warring about cosmetic differences among good languages and
focus on that guy.

~~~
bitcracker
Lisp is too powerful only for unexperienced developers because the way of
programming in Lisp is totally different from all other languages.

Actually many modern languages (Python, Ruby, Java, even C++11) copy more and
more features from Lisp since the language designers suddenly realized how
useful these features are.

Lisp was never "too powerful" but simply far ahead.

~~~
michaelochurch
Lisp makes it really easy to build infrastructure and multiplier-level (Level
2) contributions that affect the whole shop. When you have 1.3-1.4 programmers
(scale here: [http://michaelochurch.wordpress.com/2012/01/26/the-
trajector...](http://michaelochurch.wordpress.com/2012/01/26/the-trajectory-
of-a-software-engineer-and-where-it-all-goes-wrong/) ) who aren't ready to
take on projects that will affect other people in such a major way, you can
get bad results. That's a management problem, though. Inexperienced developers
_need_ to have opportunities to experiment, but if others are forced to sit
downwind of their work, then management is behaving badly.

------
sublimit
That writing style is almost schizophrenic. Tangents upon tangents, it gives a
restless impression.

~~~
dcminter
It's a Wiki. In fact it's THE wiki. Those are multiple voices.

<http://en.wikipedia.org/wiki/Portland_Pattern_Repository>

