;-) ;-) ;-)

Seriously, I don't blame myself (I'm actually very proud of my role in
getting Lisp into space, and there's very little I would change if I had
it to do over again) and I don't blame Lisp.  I don't blame anyone (with
one very narrow exception).  Shit happens.  The management giveth, and the
management taketh away.  :-)

I'm not agitating for change because I'm bitter, I'm agitating for change
because I have a problem to solve and I think change is necessary to solve
it.  That's the long and the short of it.

(Goodness, I'm in a mood today.)

Your managers seem to have abandoned a language that has produced
award winning software with the ability to diagnose and repair errors
on *extremely* remote systems in favor of a brittle language that has
a track record of incomplete projects and expensive code.

That fits *my* definition of `idiot'.

Second, whether abandoning Lisp is idiotic really depends on the spin you
put on it.  With the spin you chose (which is certainly the spin I would
choose) it does look like an idiotic decision.  But here's an alternative
spin: they abandoned a language which had a track record on only one major
project, and on that project it was a neverending management nightmare
because the Lisp programmers seemed to think that they were smarter than
everyone else.  The result was a breakdown in team coherence and a
year-long delay in mission launch (which is a very serious matter I might
add).  And then in the end the code was buggy and required ground
intervention in order to save the spacecraft.

See?  When you look at it like that it suddenly doesn't seem quite so
idiotic, does it?  I'm not saying this is a fair view of the situation (it
isn't), but it is defensible, and that's how a lot of people around here
remember it.

    JM> This must be because of the numerous success stories
    JM> concerning rewriting Lisp projects in C++.

Please don't ever quit posting here Joe.  Laughter aside, I have heard
this rumor about yahoo wanting to rid itself of Lisp before.  Why?
[Where] is this written up?

cheers,

I agree, that was very well put...should be pinned on a wall here, somewhere
;)

:)

--

Second, Yahoo's desire to get rid of Lisp is not documented.  I know it's
so because I interviewed for the job of porting the code to C++.  (I
didn't get the job because I could not keep a straight face during the
interview, and eventually ran screaming from the room.  Well, not quite,
but close.)

I'm in a much different sort of industry; a small startup.  My argument
for using lisp is: "If you want to outcompete the herd, you can't do/use
what the herd uses: you have to be smarter and faster".  Again, to me, this
is self-evident, and my managers agree with me and let me choose the
technologies on their technological merit.

If managers need that amount of detail, they should probably be willing to
hire those market analysts who sell reports printed on glossy paper.

  Knowledge-Based Applications That Employ Dynamic Objects Technology
  http://www.franz.com/support/tutorials/docompanies.lhtml

  CL/CLOS and C++ - An Overview of C++: The Good, the Bad and the Ugly

http://www.franz.com/resources/educational_resources/clos_versus_othe...

The recent evolution of missions to faster processors and bigger
memories will open up the possiblities for very different and much
more complicated flight code.  When you don't have to count very
nearly every cycle and shoehorn code into little bits of memory,
something like CL becomes lots more palatable, and when you start
raising the spectre of updating the system while in operation, quite
attractive.

  Perhaps they are mortally afraid of betting their money on the
  competence of their programmers?

--
Erik Naggum, Oslo, Norway

It seems to be the essence of the American definition of success.  Competition,
eating your young and weak.  I worked for a small company up here
in Canada with some American clients.  The boss sat us all down and said,
"Don't make any mistakes with our clients, they will use it against us".  And
you know, they did, they would rub the mistakes right in our faces.  Good
thing my ego was not dependent on their approval.

But I understand your point - it clearly matters whether Lisp is
actually used in anger by people who are making money.  Except, maybe
it doesn't...

Here's my theory about these kind of questions.  Really, what is being
asked here is `OK, so you're suggesting that we do x, well, before we
make a decision I'd like to know who else is doing x?'.  Perhaps an
expansion of the question would be `who else that is like us is doing
x?'. Why ask this question?  I think the reason is often `because we
don't want to do anything unusual, we want to be just like other
people'.  If that's what is driving these questions, is it a
reasonable attitude? Sometimes it probably is: `what accounting system
do other companies our size use?  Probably we should use that too'
seems pretty reasonable (it's certainly how *we* decided what
accounting package to buy!). But in other cases it reeks of
cowardice or stupidity.

The cowardice case is this: `we're a company doing x, we have n
competitors and there are a bunch of other companies about the same
size: let's look at what they do, and do the same thing'.  The likely
outcome of this is that you'll do about as well as they do, and you'll
probably stay in business, and you didn't have to think too hard to do
it.  Of course, if `what they do' is something that's very
inefficient, you'll be doomed to be inefficient too, but at least
you'll only be as inefficient as they are.  In the case of software,
well, your projects will be late, over budget and 80% will just fail,
like theirs do.  But no one ever got sacked for choosing C++.

The stupidity case is this: `we're an organisation that put people on
the moon, and now wants to land a man on Mars in the next 10 years:
there aren't any other people doing what we do, but lets look at some
other people who are doing something different and much less
demanding, but perhaps we can convince ourselves that they're like us
in some nebulous sense, and see what they do, and do that'. This
organisation has forgotten how it got people to the moon.

Me, I'd like to work somewhere where people made decisions based on
their own opinions, rather than herd instinct or stupidity.
Unfortunately it's hard to find such places, unless you make them up
yourself.

 > (defun foo (x)
     (plus x "n"))
Warning: "plus" doesn't seem to accept strings as parameters - shall I
accept the definition of "foo" anyway? (y/n)
 > y
function "foo"
 >

Of course, the environment should allow you to disable the interactive
mode and either automatically accept or reject everything. Such a
feature would make everybody happy: fans of dynamic typing as well as
people who generally or perhaps only occasionally prefer static typing.

 > (let ((*static-typing* t))
     (defun foo (x)
       (plus x 5)))

Pascal