

Why were Lisp machines so expensive? - globalrev

Going through SICP, in the last lectures they are going through register machines, compilers etc.<p>Abelson mentions a for LISP-chip/machine that was more parallelized(yeah spell that) than an ordinary chip.<p>What was the advantage/disadvantage with LISP-based machines?<p>They were more expensive I have heard, but why? Harder to make because they needed more parallelisation or just because there was less demand for them?<p>Are new multicore computers more like LISP-machines were?<p>Some relevant links:
http://pt.withy.org/publications/LispM.html
http://fare.tunes.org/LispM.html
http://www.ugcs.caltech.edu/~weel/lispm.php
http://en.wikipedia.org/wiki/Lisp_machines
This is cool, didnt know of it before:
http://en.wikipedia.org/wiki/Tagged_architecture
======
ajross
The MIT CONS computer and its commercial descendants at Symbolics and LMI was
not a parallel architecture. It was a fairly conventional uniprocessor CPU
which happened to have a register and instruction architecture that provided
some hardware acceleration for typical "LISP" tasks (specifically tagged
pointers: the "pointer" value had a bit telling the CPU whether to load the
value as-is or indirect through it to load the next value).

As for why they were expensive: they were small market pre-VLSI minicomputers
being sold in the late 70's and early 80's. They competed most directly with
machines like the MicroVAX, and weren't particularly expensive for that
market, AFAIK. Assembling and testing a few thousand ICs into a single
computer is just inherently expensive.

------
edu
Well, I suppose that the conjunction of a lower demand and a more complex
processor (which executed Lisp directly) is a good reason for them to be
expensive. The complexity is a problem in the beginning, and if the demand had
been higher the prices would lowered, but... I think the main reason of the
failure was due to the business side and not the technical merits,
unfortunately history shows that technological success has more to do with
business skills (i.e., ms) than with the technology (i.e., Lisp Machines, 80's
Apples...)

~~~
chandler
>> (which executed Lisp directly)

Uh, the machine's architectures were probably designed to be more amenable to
Lisp-esque features (e.g., garbage collection, tagged types at runtime, native
pair operations, etc); I suspect the machines didn't execute Lisp directly for
the same reason that an x86 doesn't execute C directly...

~~~
cpr
The microarchitecture really implemented Lisp primitives like cons, car, cdr,
array ref as opcodes, etc. That's about as close to executing Lisp directly as
you can get.

~~~
ajross
That's how it's commonly explained, but it's not really correct. The
bitsavers.org folks have a copy of the original Lisp Machine paper:

[http://www.bitsavers.org/pdf/mit/cons/TheLispMachine_Nov74.p...](http://www.bitsavers.org/pdf/mit/cons/TheLispMachine_Nov74.pdf)

The pointer/register format was very LISP-friendly, but the actual
instructions are much more conventional. The trick is that instead of having
to test the tag bits with separate instructions, the "load" instruction
equivalent does it in hardware.

~~~
cpr
Well, if you look on pages 13-14 of the manual you referenced, you'll find
instruction codes for PCAR, PCDR, SCDR, SCDDR, NCONS, CONS, LIST (alloc),
CxxxR, CxxxXR, GET, GETL, ASSQ, ASSOC, etc. Seems like Lisp primitive
instructions to me.

------
anamax
The cost of lisp machines also include much of the cost of developing the lisp
machine environment. That probably cost more than the software that came with
suns, apollos, etc and the workstations had more volume, so their comparable
cost per machine was significantly less.

