
The Rise and Fall of Lisp at the Jet Propulsion Lab. - spydez
http://www.flownet.com/gat/jpl-lisp.html
======
silentbicycle
So it sounds like the JPL's reason (at least the reason they gave - whether
you want to believe it was some anti-Lisp conspiracy or just bad office
politics is your own business) was that Lisp was too _big_. I wonder if Scheme
would have been a better fit? (It was certainly around in 1988; SICP was
written in 1985.)

There's something about Lisp that gives it a reputation as inherently
individualist (as opposed to the "workers are expendable cogs" project
management model that the linked article associates with Java). Same with
Forth. At this point, the Lisp community seems to encourage that idea, but
what in the language itself supports this?

I hear arguments that it's a harder language, but let's not kid ourselves. I
think programming well in, say, C++ or Haskell is much, much harder. (
_Should_ a language be hard to use well?) Or: Lisp code is hard to read.
Potentially, sure -- the readability of the code is more dependent than most
languages on the developers' abilities to name things well. (Same with Forth.)
You can write unmaintainable garbage in any language, though - just copy and
paste things where they're used instead of naming and referencing them, give
variables meaningless names, etc. Just add water and presto, _big ball of
mud_. (<http://www.laputan.org/mud/>) Also, most programmers are probably used
to good editors handling paren balancing in any language.

Besides being significantly different from the main languages people are
exposed to, what? All it takes for a language to be different from e.g. C/Java
is to not _be_ C/Java. Is it because you can create your own idioms /
extensions to the core language? I also think the syntax is something of a red
herring - sure, you may dislike the syntax, but I can think of popular
languages that have disastrous syntaxes. (I guess Dylan could be a control
group here, but I don't know anybody who has real experience with it, let
alone its reputation among management.)

No answers, but I'd really like to know. Working on my own language, and all
that.

Also: I'm most definitely not looking for thinly-veiled bragging about how
"not everyone can handle such a superior language" either, because... come on.

~~~
jrockway
_There's something about Lisp that seems inherently individualist. At this
point, the Lisp community seems to encourage that idea, but what in the
language itself supports this?_

I think the people that choose Lisp select it after a study of the various
options. Choosing and evaluating programming languages is not a social
activity -- you do it by yourself. Contrast this to Java programmers, who use
Java because it's what they learned in school. They aren't individualistic,
they just do what they are told.

(Java's popularity is helped by the "tools" are "easy to use". SLIME and Emacs
are "hard to use", so you have to want to use them to be able to use them. I
use quotes because I disagree with the sentiment. Eclipse is a nightmare to
use. Emacs is a dream.)

As for Java's popularity, I think it comes down to social factors rather than
differences in the syntax of the language. Java developers want less money
than Lisp developers. It's also easier to hire Java developers, because you
can just require a Sun certification. Easy!

~~~
gaius
I don't think that's true. Lisp jobs are few and far between; people who want
them _really_ want them. There are many jobs that are like that. Here in the
UK nurses and firemen are badly paid, that's because there's always someone
who wants the job enough to do it for barely living wages.

The only way to be a well-paid Lisp programmer is to work somewhere where they
wouldn't even dream of using Java.

~~~
jrockway
I've found that the better a job suits me, the more they are willing to pay
me. (I have never looked for a Lisp job, though.)

------
jimbokun
I read this before, but still love this conversation with his Google manager:

Me: I'd like to talk to you about something...

Him: Let me guess - you want to use Smalltalk.

Me: Er, no...

Him: Lisp?

Me: Right.

Him: No way.

I just find it an amusing encapsulation of how so many of the high achieving
people that Google hires like to program in high productivity languages like
Lisp, Smalltalk, Ruby (see Yegge) but Google keeps a tight rein on it by
keeping the languages they will deploy on their servers down to 4 or so
(Python, C++, Java and Javascript being the 4 I've heard).

~~~
silentbicycle
I can see where they're coming from, though: If every time a new popular
language came out (Ruby or Clojure or Blorf or Java+++ or ...) somebody wanted
to also add _that_ as a dependency, it would quickly become a maintenance
nightmare.

At the same time, Smalltalk and Lisp were both languages with decades of
history, so it was something other than managers trying to help focus
programmers who (understandably) want to try out every new shiny thing. What,
though? (See my other comment.)

~~~
gaius
Facebook use 20+ languages in production - that's what Thrift is about.It's
certainly do-able so long as certain processes are in place (e.g. if you use a
language you are responsible for its bindings to the common message bus).

~~~
silentbicycle
Whoa, yikes. Can you give me a reference for that? (Or even tell me _which_
20?)

~~~
gaius
There's a 'Facebook Engineering' group on Facebook where they blog about their
internal operations.

------
gibsonf1
Is it just me, or is the idea of using a repl on a computer in space simply
fascinating?

~~~
bayareaguy
What I found more interesting was this section in the story of the Remote
Agent bug ( <http://ic.arc.nasa.gov/publications/pdf/2000-0176.pdf> )

 _One of the errors found with SPIN, a missing critical section around a
conditional wait statement, was in fact reintroduced in a different subsystem
that was not veriﬁed in this ﬁrst preﬂight effort. This error caused a real
deadlock in the RA during ﬂight in space._

So the bug fixed with the repl was actually one that was uncovered by the SPIN
verifier ( <http://spinroot.com/spin/whatispin.html> ) months prior to the
launch, but wasn't fixed because they didn't verify the code they actually
decided to use.

------
DaniFong
_In the words of Elton John: It's sad. So sad. It's a sad, sad situation. My
best hope at this point is that the dotcom crash will do to Java what AI
winter did to Lisp, and we may eventually emerge from "dotcom winter" into a
saner world. But I wouldn't bet on it._

------
ph0rque
> Copyright (c) 2002

So what happened in the ~6 years since then?

~~~
lisper
I quit JPL and started a new career as a VC :-)

~~~
ced
Do you have that written out in another post somewhere? I loved this one.

~~~
lisper
Nope. I haven't been doing it long enough to have gotten any good stories out
of it yet. I did write this a while back, which was a big hit in its day:

[http://rondam.blogspot.com/2006/10/top-ten-geek-business-
myt...](http://rondam.blogspot.com/2006/10/top-ten-geek-business-myths.html)

------
zandorg
Lisp at the very least is excellent for initial prototypes.

------
logjam
"The situation is particularly ironic because the argument that has been
advanced for discarding Lisp in favor of C++ (and now for Java) is that JPL
should use "industry best practice." The problem with this argument is
twofold: first, we're confusing best practice with standard practice. The two
are not the same."

To me, this is the crux. We have this ridiculous idea that "industry" drives
technological advance.

Industry software "engineers" trained up in trade schools or worse, without
any awareness that they are reimplementing solutions (poorly) to problems that
were solved _decades_ ago...and we get...horrible industrial monstrosities
like Java (and Microsoft Windows) roaming the earth, while remote diamonds
like Lisp and Scheme shine kindly down.

~~~
briancooley
_Industry software "engineers" trained up in trade schools or worse, without
any awareness that they are reimplementing solutions (poorly) to problems that
were solved decades ago...and we get...horrible industrial monstrosities like
Java_

Since Guy Steele coauthored both the Lambda Papers (late 1970's) and the first
three editions of the Java specification, I don't think that you can
successfully argue that awareness of anything solved by Lisp or Scheme was a
problem in the development of Java.

I always got the impression that the goal with Java was to make bad
programmers better, not to create the ultimate language (e.g., see
[http://fishbowl.pastiche.org/2004/03/17/halfway_between_the_...](http://fishbowl.pastiche.org/2004/03/17/halfway_between_the_gutter_and_the_stars/))

To use a golf analogy, consider cavity back irons. The average golfer, who
struggles to hit it straight, will likely play a lot better with cavity backs.
But a really good golfer won't be able to shape shots easily and will feel
hamstrung without his blades.

~~~
tjr
_I always got the impression that the goal with Java was to make bad
programmers better, not to create the ultimate language_

And you would be correct...

[http://people.csail.mit.edu/gregs/ll1-discuss-archive-
html/m...](http://people.csail.mit.edu/gregs/ll1-discuss-archive-
html/msg04045.html)

