Let me first tell you how I acquired my faith in Lisp, because my
experience was very different from yours (as told in
http://groups.google.com/groups?selm=3208226254834485%40naggum.net&ou...)

I started using Lisp in high school, in 1979, on an Apple II.  It was my
third (computer) language, after Basic and Pascal.  I fell in love with it
almost right away even though in retrospect I really didn't "get it" for a
very long time.  (Maybe I still don't.)

In those days I was growing up in Oak Ridge, Tennessee, a town of about
30,000 people, whose main industry is a nuclear research facility, so I
had the good fortune of being around a lot of really smart people, but
they were mostly nuclear engineers and physicists, not computer
scientists.  They knew a lot about fortran and how to solve differential
equations, but I was interested in AI.  I wanted to build autonomous
robots.

I was drawn to Lisp for three reasons.  First, it was the language of
choice for the area of work I wanted to get into.  Second, it struck me
right away as more aesthetic than Pascal or Fortran, and aesthetics are
important to me.  Finally, it was just so much easier to get things done
in Lisp than in any other language.  And not just by a little bit.

This was really driven home in college, where I used Lisp while my
colleagues used Pascal and C (and sometimes PL/I or Fortran).  What took
them days and weeks to do took me hours or minutes, and not because I was
that much smarter than they were, because when I wrote code in Pascal my
performance was actually much worse than theirs.  I particularly remember
my first graduate course in compilers.  I did my work in Lisp while my
colleagues all used Pascal.  They turned in reams of printouts (some were
literally a foot high), while my entire output for the term was maybe
twenty pages of code (including comments).

That experience convinced me of two things.  First, using Lisp was the
Right Thing and second, many things (perhaps most things, perhaps all
things) that appear to be hard are actually easy.  (I have since changed
my mind on both points, but I'm getting ahead of myself.)

The next ten years pretty much confirmed these lessons.  Around 1986
Macintosh Common Lisp (then called Coral Common Lisp) came along, and I
never looked back.  As a programming environment it is still in class by
itself even after fifteen years.

<tangent>
I used a Symbolics Lisp machine for a few years in the late eighties and
my experience with it was very unfortunate.  I found the LispM to be
horrifically complicated and badly underpowered for what it was trying to
do.  I often got myself into situations where the machine was many, many
seconds, sometimes minutes, behind my keystrokes.  It was so frustrating I
eventually just gave up on it and went back to my Macintosh.
</tangent>

In 1988 I went to work at JPL, and again I found myself running rings
around other programmers by using Lisp.  I did things (like write
compilers for little mini-languages) that people using C (there was no C++
at the time) wouldn't even contemplate attempting.

At JPL I encountered an interesting phenomenon.  I would have proposals
rejected on the grounds that what I was proposing was too hard and
couldn't be done, when in fact I knew that what I was proposing was
actually quite easy (if one used Lisp).  It got so bad that I would
actually develop prototypes as part of the proposal writing process just
so that I could say, "Not only is this not hard, it has already been
done."  (It actually got even worse than that, but putting the details on
the record would not be healthy for my career.)

I also encountered an astonishing prejudice against Lisp and towards C.
Between 1988 and 1991 I worked on the research program that led to the
Mars Pathfinder rover.  We built three prototype rovers during that time,
and I either wrote the code or supervised the person who did on all of
them.  All three of them were programmed not in Lisp, but in little
mini-languages whose compilers were written in Lisp.  (The rovers
themselves only had 8 bit processors with a few hundred or a few thousand
bytes of memory so we couldn't run Lisp directly.)

But when it came time to write the code for Sojourner they wrote it in C.
As far as I know the possibility of using the work we had done on the
prototypes was never even considered.  All I know is that I was never
approached about it.

A similar thing happened many years later on a project called Remote Agent
(RA), which was a flight experiment to demonstrate an autonomous control
system for a spacecraft.
(http://ic.arc.nasa.gov/ic/projects/remote-agent/)  At the beginning of
the project we had a lot of prototype code written in Lisp, so it seemed
natural to me to just fly Lisp aborad the spacecraft.  The resistance to
this idea was tremendous and unrelenting.  Fortunately, we resisted
successfully.  I say fortunately, because at one point an attempt was made
to port part of the code (the planner) to C++.  Afer a year that effort
had to be abandoned.  On the basis of that experience I think it's safe to
say that if we hadn't used Lisp the Remote Agent would not have happend.

Nonetheless, it was not an unconditional victory.  RA was part of the
first New Millennium mission, which was the flagship for Dan Goldin's new
"better, faster, cheaper" initiative.  As a result we were given a budget
and schedule that everyone knew up front was impossibly tight.  When the
inevitable schedule and budget slips hit the fan, Lisp became the
scapegoat.  The software integration engineer was asked at a very
prominent review board hearing (attended by over 100 people) what was the
most significant factor causing the schedule slips.  His reply: Lisp.  As
a result, RA was down-graded from the mainline flight software to a
two-day flight experiment.

That was pretty much the end of Lisp at JPL.  On my next project I tried
again to sell it, but the political damage done by the Remote Agent
experience was insurmountable.  Finally, out of frustration, I quit JPL
and went to work for Google.

I went to Google with my faith fully intact.  Let me be more specific
about what I mean by that.  I had the following mindset, cemented by
twenty years of experience:  first, Lisp is great.  It lets you be orders
of magnitude more productive than C, and it's much more reliable (no core
dumps!).  Second, because Lisp is so great, the only reason a rational
person would choose not to use it is if they were ignorant.  There
certainly were an awful lot of ignorant objections to Lisp at JPL.  (BTW,
ignorant is not a pejorative term.  If you think it is you are ignorant
and you need to go look the word up in a dictionary.)  Third, I thought
that this ignorance could survive at JPL because it was not subject to
market forces.

There was always some niggling doubt in my mind about this last point.
Over the course of twenty years the following question had begun to bother
me more and more: if Lisp is such a massive productivity gain over C, why
doesn't it win in the market?  At JPL suboptimal strategies can survive
because we're an FFRDC (federally funded research and development center)
and therefore somewhat insulated from market forces.  But out there in the
real world there ought to be some people using Lisp to whomp the pants off
the C-using competition, and it just didn't seem to be happening.  I came
up with the following theory: lots of people are using Lisp, but they
don't want the competition to know because they want the competition to
keep using C.

It was a plausible enough theory, except for two things.  First, a secret
of this magnitude would be awfully hard to keep, and second, my own
experience in trying to hire Lisp programmers demonstrated to me that they
are very hard to find.  I was reasonably well known in the Lisp
community.  If there really were lots of people out there secretly using
Lisp and programmers were scarce I would have expected to find myself
being recruited, but I was not.  At this point I was seriously considering
the possibility that there really was a thriving Lisp economy out there
somewhere, and that I was being excluded from it for some reason, like
maybe my reputation for being obnoxious.  (But even that theory came
unraveled when you showed up, Erik.)

So I can't really go into many specifics about what happened at Google
because of confidentiality, but the upshot was this: I saw, pretty much
for the first time in my life, people being as productive and more in
other languages as I was in Lisp.  What's more, once I got knocked off my
high horse (they had to knock me more than once -- if anyone from Google
is reading this, I'm sorry) and actually bothered to really study some of
these other languges I found *myself* suddenly becoming more productive in
other languages than I was in Lisp.  For example, my language of choice
for doing Web development now is Python.

I also saw Peter Norvig come to Google and leave Lisp behind with no
apparent regrets.  (Actually, Peter and I had talked about this while we
were both still at NASA, and he was already leaving Lisp behind, which I
found very distressing at the time.)

Finally, I read Paul Graham's recent writings.  He's the only person I
know of who has actually gotten wealthy using Lisp.  That doesn't make him
infallible, but I think it does make it prudent to pay attention to what
he has to say.  At least when Paul says, "That's how I got to where I am,"
I don't have to wonder where that is.

That's the story in a very large nutshell.  What happened when I lost my
faith was that I could no longer sustain it in the face of mounting
evidence to the contrary.

Let me just make two comments to those of you who have had the patience to
read this far: 1) thanks, and 2) my aim here is not to diss Lisp.  My goal
is honestly constructive.  I think that if Lisp does not evolve it will
die, and I don't want to see that happen.  I still think Lisp is great.  I
also think it can be, and should be, improved.