[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Lisp Machines vs. T on an Apollo

I find that comparing T on an Apollo and ZetaLisp on a
Lisp Machine is a little like comparing apples and oranges.
I use both, they are tools designed to solve different
problems. We have nine Lisp Machines in our group, and I
have one in my office. 

Lisp Machines provide an environment that allows rapid
implementation of substantial size programs by expert
users of Lisp Machines.  It takes a very long time for
people to come up to speed on a Lisp Machine, and they
are often counter productive while they are starting up.
Thus, not only are the machines themselves expensive,
but the cost of training new users is very large.
Another problem with Lisp Machines is that the software
producted on them is not very robust.  The prime example
is the Lisp Machine software.  Notice that to this day,
they have not implemented closures correctly, dispite
bug reports from us dated over a year ago.  The problem is
that everything is easy to change, even for non-experts.
Unfortunately, non-experts usually make changes for the
worst.  In the interest of excluding profanity from this
letter, I will not comment on ZetaLisp, except to say that
if CommonLisp is the ADA of Lisps, then ZetaLisp is the
PL/1 of Lisps.  You'd think people from MIT could do better.

T on the Apollo is ideal if you want to reduce the amount
of time require to train useful Lisp programmers.
The lack of Lisp programming tools is more than made up
by the better feel T programmers have about computation.  
They program better because the think about 
their programs more clearly.

I use the Apollo because T allows an implementation of
languages I create that looks very much like its semantics.
I require that procedures are first class data objects,
and depend on optimized tail recursion. With T, I get to
write what I mean, not some weird translation consistent
with a stack machine (the reason you can't simply move
T to a Lisp Machine is that the micro code implements
a stack machine in a fashion that makes optimized tail
recursion impossible).

You should choose the right tool for your application,
but don't believe the sales pitch Lisp Machine sales
people give.  I'm looking forward to the day when T is
available on the Suns, so I can use it on more than the
one work station.