The LispOS Project: a position paper, part 1

[Dwight Hughes]

| From: Scott L. Burson <gyro@zeta-soft.com>
| 
| I. General Comments
| 
| First off, I would point out that the current state of uncertainty is
only
| natural.  There is the temptation to compare this project to Linux; but
| building Linux, although a very large implementation effort, was
relatively
| straightforward in the sense that the goal was well-defined: duplicate
Unix.
| The kernel design and implementation strategies were well-known when
Linus
| started.  This meant that he could practically just sit down and start
coding.
| I don't mean to diminish his achievement; I'm just pointing out that we
are
| not in the same situation.  Oh, I suppose we could just try and duplicate
the
| LispM, but that doesn't strike even me, a die-hard LispM fanatic, as a
useful
| goal.
| 
| So I think we just need to accept that it may take some time for a
consensus
| to emerge on goals and strategy.  It certainly doesn't bother me that
this
| can't be pinned down in a month.  And even once we select a strategy,
there
| will be many details to attend to.  Better to invest some thought up
front
| than to get to the middle and discover it's not going to work the way we
| thought.

This certainly makes me feel better about where things are and what is
happening
in the project. It *is* a hell of a task, and a most interesting one - one
that
deserves some patience and care in setting it up.

| II. Goals
| 
| As I listen to this conversation, I hear a number of ideas about what
people
| want LispOS for.  Let me see if I can enumerate the major ones:
| 
|  -- a highly flexible, mutable system, with as much source code in Lisp
as
|     possible so we can change practically anything we want to change
| 
|  -- something lots of people will want to use
| 
|  -- a basis for other work, i.e., something on which new kinds of
programs can
|     be written (this is my own desire; I don't know if anyone else here
shares
|     it)
| 
|  -- a testbed for various research ideas in language design, compilation,
|     etc. etc.

I see points 3 and 4 as corollaries of point one, but I suppose that need
not
necessarily be the case. (If we do the job right they should be.)

  [ various excellent commentary on what is necessary for "popular
acceptance" ]

For myself "popular" acceptance is not high on my list so long as we
attract a
strong group of users (fanatics?) who will support and advance the system
as
time goes along and add significant value to it. The needed "killer app"
may not
even be a germ of an idea yet. If the LispOS becomes what we desire, it
should
enable many things that were never considered as practical or reasonable
before -- from this will come who knows what. Java is not especially
wonderful
in itself, but it possessed several characteristics that made it suitable
to
act as an enabler for technologies that were suddenly desirable. Perhaps
we will get lucky too.

A fundamental need of the LispOS is easy interoperability with just about
everything out there. That alone would make it valuable to many people.

| So perhaps the first question to ask is, Who is the intended audience for
| LispOS?  This deserves some discussion.  I see a few groups who might be
| served:
| 
|  -- students who want to see another view of the computing world than the
|     C/Unix orthodoxy; possibly also, educators who want to expose their
|     students to such a view (I'll call these "academic users")
| 
|  -- researchers in language and OS design and implementation who want to
|     try out their ideas, and to share ideas with others in a concrete
form
|     ("CS researchers")
| 
|  -- professional programmers who want easier ways to build applications,
and
|     to build new kinds of applications
| 
|  -- AI researchers, like myself, who could never quite build the systems
we
|     wanted to build on the available platforms
| 
|  -- general users who want a system that functions more automatically and
|     intelligently than current designs

I would add users/companies who need higher levels of fundamental
reliability
and incremental reconfigurability in place without rebooting. The
fundamental
"safety" of an OS based on tagged objects from the ground up could be
valuable
in all kinds of process control, semi-embedded systems, work-flow, and
anywhere
else you need a system that *has* to run.

 [ more excellent exposition snipped ]

| And finally, general users.  I have thought a little about what value
LispOS
| might provide an unsophisticated user.  This is just an idea, and it's a
bit
| of a long shot, but it does strike me that today's computer systems are
still
| far too hard to use.  People need them to be self-administrating to a
much
| greater extent; to build a detailed model of the user and his/her goals
and
| preferences; and particularly, to provide much more intelligent handling
of
| errors of various kinds.  This is something a fully integrated system
like
| LispOS could do far more easily than a present-day OS.  Again, this
deserves
| more thought, but I wanted to toss it out there.

As a consultant who deals with various networks and needs and neophyte
users,
there is definitely a need for better, far more adaptable and configurable
server OS. LispOS could make a great contribution here - being able to
adaptively use and reorient resources based on need and availability would
be awesome. Simply having a server OS smart enough to know "whoa, dude,
that
printer's toast, better reroute my queue to an equivalent one and tell the
user where to pick up their output" would save so many headaches for users
(and for me).

-- Dwight