LispOS already under development?

[Paul Prescod]

I believe that if we take a pragmatic approach to what we hope and
expect to accomplish, we will find that we are not far from a usable
Lisp-Machine like environment. I'm just guessing what was important
about those machines, but I think I've got a handle on it. I propose
that this environment be built on top of a modified JVM -- the "UVM"
people have been discussing. Here is my argument:

One of the best features about the Lisp machines was that everything
resided in one address space: this is also a feature of the JVM.

Another important feature of the Lisp machines was that programs did not
pass around data in brain-dead formats like untyped pointers or flat
strings. They passed around real objects. The reason that Lisp on Unix
is unsatisfying is because everything must be converted in and out of
Lisp types. This is also a feature of the JVM: everything is an object,
people only work with strings and pointers when conversing with the
outside world.

Presumably the Lisp machines also had rich libraries and applications
available that fit into the "everything is an object" world. Well so
does the JVM, and the number of libraries and applications are
increasing every day.

Two other important features of the Lisp machines were that they were
optimized for Lisp at the user interface and hardware level. Well, in
the JVM we can build whatever user interface we want, including Emacs or
recreations of the LispM UIs. And it is not entirely inconceivable that
our extensions to the JVM might become standardized and be incorporated
into future "JVM chips." Anyhow, as long as Java supports garbage
collection, runtime type identification, runtime array bounds checks and
so forth, we benefit from any fast hardware or software support that is
developed.


We do not, on the other hand, want to repeat the failure and death of
the Lisp machines. We do not, therefore, want to copy their mistakes. No
matter how poor the management of those companies, I think that "being
different" and incompatible in various ways had something to do with the
death of those machines. That mistake would be so much worse today. The
platforms are converging (slowly) -- I can use bash and GCC on Windows
95. I can write GUI apps on Unix with Java and run them on Windows or
the Mac. The Internet makes this a huge priority. Nobody wants a
platform that can't run the latest and greatest apps. It isn't even
clear if anybody other than those on this list really want a new
operating system: a new environment, maybe. But who cares about the
kernel anymore? A new operating system would be so far behind in this
integration that it would be very had to get critical mass.

I propose, therefore, that we 

a) help Per Bothner to improve Kawa on the JVM until it is
feature-comaptible with Guile.

b) help Olin Shivers, IBM, GNU and whoever else is interested to improve
the JVM until it can run dynamic language code efficiently.

c) help GNU to port Emacs onto Guile/Kawa.

d) make some really kick-butt applications and libraries for Lisp in
JVM.

Rather than isolating ourselves from the mainstream, we should thrust
ourselves into the middle of it and show them how much better our
technology is. Otherwise, 2 years from now we'll be asking: "Why is TCL
still so popular? Lisp on LispOS is so much better. Sure, you can't use
these apps on other operating systems. Sure, you can't run apps from
other operating systems on it (efficiently), but it is still *better*."

For once, let's take the Larry Wall approach. I want to be able to hack
in Lisp (and even get paid for it!) within my lifetime.

 Paul Prescod