Why LispOS?

Rainer Joswig joswig@lavielle.com
Fri, 27 Mar 1998 23:51:33 +0100

At 21:38 27.03.98 +0100, Rodrigo Ventura wrote:

>design. Although it seems to me that it has much less flexibility than
>X has. For instance, is it trivial to run apps on a remote server?

My response is about Windows (not NextStep).
Windows can run applications over the Network. NT 5.0
will have this. The new Javastations from SUN should
be able to connect to NT servers and run Windows displays.

>Well, for one thing, it is not closs-platform.

Win32 implementations are available for Unix.
NextStep is cross platform (OpenStep, Yellow Box).

> X supports window managers that can change radically the look and feel.

Well, I would say this one of the biggest flaws with X.
Window managers and desktop environments in X are generally
either ugly (Motif), buggy (OpenWindows), poor on user experience
(Motif, CDE, ...), desintegrated, non-standard exoticly designed,
... In general you can say that a common wm and desktop environment
(CDE) has come much too late. Doesn't every keypress still go over the
network in X?

Actually I don't care that much about X Windows, the
Symbolics can deal with several window systems at the
same time, including X Windows. So it is possible to use
the same Genera environment from its console (whether it
is a LispMachine with its native windows system or a MacIvory
with a Mac OS window system) and also from multiple X displays.

> Guess that
>doesn't happen with NeXT. In general, X seems to me much more flexible
>than NeXT.

Actually the Next system has an object oriented implementation
and a nice UI designer (well this one has first seen light
on a Mac written in Lisp).

>"sucks". (can you elaborate more than in terms of "do/don't suck"?)

Newton OS has a clever design. Some Unix systems also have a better
design (on top of the more traditional and ugly parts of Unix), like AIX.

The revolutionary OS that provides a radically different view is needed.

Unix, Windows and MacOS are architecturewise misdesigned,
bloated, buggy, expensive to maintain (guess how expensive
the development of a Windows NT port to a different machine is?),
old fashioned (since MacOS in 1984 the MacOS UI hasn't changed
substantially, ...), really complicated to program,
full of obsolete "tools" which each have different
UIs with duplicated functionality all over the place (Unix), ... 

In part I would agree that a Lisp OS might not be an end user
OS (Genera never was). Still I think you can design a system
with all the Lisp features and put it in the hand of end users. Best example
is the Newton OS. It is like a Lisp Machine objects all the
way down, a frame based object system with persistent storage,
GC, builtin compiler, fully dynamic, ...

Imagine you can collect your information system wide in frames and
you also can modify your schemas at will. Every user action
will instantly stored, indexed, compressed without the
need to ever press a save button or to determine
a memory location (file, directory, ...).

Imagine a clever design of your subsystem as CLOS components,
your OS might be able to choose alternatives from a range
of implementations or services. Every component is organized
in an agent like fashion. Every component can provide
information about its capabilities. Querying on the net
for a certain service description (who can calculate
the telephone log for telephone system lav1?) gets you
a collection of agents and costs for their service. Then
you will invoke one of these agents, given that you have
enough "money" to pay them. Imagine data mining in
large collections of live objects.

Imagine a system that doesn't find information in files and
hierarchical directories, but as results of queries. Those
results can be displayed on 3d trees, walls, timelines, . Imagine
those displays being directly connected to the real data. Just by clicking
on them you will get all the context specific operations no matter
what global context you are in. 3d/2d from day one. 

Imagine a system where the documentation does not come as dead
collections of prerendered HTML files (which seems
to be currently envogue), but via a server that generates
the presentations of the data on the fly, by taking the
users interest into account (developer, OS developer,
student, interested in overviews, details, additional linked
data, ...). Yes you will get indexes and content overviews
instantly and for free. Adding documentation is just a matter
of entering documentation records. Updating is instantanious and
the information is system wide available. You can view the
same documentation in your editor, from your browsers,
in the shell - and it always looks perfect and provides the
same navigation (just click on what your are interested).

Imagine having a real "command" abstraction. The command
can be invoked by keyboard, clicking, dragging, event,
command line, voice, gestures, whatever. Still
the underlying command has only to be implemented
once. Have parsers for english-like command languages
(Insert User Rainer Joswig, Add Host camille to the
X Access List, Run The Telephone Log Calculation For Yestersay, 
Where is Rome?, What Are My Appointments For Tomorrow?, ...).
Have links between data items.

Actually most people are too blind to see what can be done
and what would be really fun, because they are bound by 
what they know (Windows or Unix). They think commands
have to have names like "grep" and "find ./bar -name foo -print".
They think they have to have grey dialogs - those will
depress them even more - like in Windows. The result is
that they will copy, copy, reinvent, copy, and copy.
The result is that progress is incremental - if at all.
I'm now typing to a text editor, which is less capable
than what my Lisp machine had ten years ago. Why?