another topic (which language to use)

[Marco Antoniotti]

   Delivery-Date: Fri, 25 Apr 1997 08:33:42 -0700
   Resent-Date: Fri, 25 Apr 1997 11:11:40 -0400 (EDT)
   Date: Fri, 25 Apr 1997 10:07:42 -0500 (CDT)
   From: David Gadbois <gadbois@cyc.com>
   CC: lispos@math.gatech.edu
   Resent-From: lispos@math.gatech.edu
   X-Mailing-List: <lispos@math.gatech.edu> archive/latest/25
   X-Loop: lispos@math.gatech.edu
   Precedence: list
   Resent-Sender: lispos-request@math.gatech.edu

   I argue for using Common Lisp.

I definitively agree on this.  Moreover I would regard any effort that
excluded the possibility of supporting a full blown CL as misled and
poorly thought out.  Note that a support layer for CL would be
necessarily a support for Scheme.

   Advantages:

   o Standardized object system, exception handling, bit-banging, other
   libraries.

   o Semi-standardized thread and FFI APIs.

   o Existing big and useful system applications (CLIM, CLX, CL-HTTP)

   o Existing OSes to use as examples (or counter examples!)

   Disadvantages:

   o Relative paucity of off-the-shelf implementations to use (CMUCL,
   clisp, GCL).  On the other hand, for a full-blown OS, the actual
   language implementation is a pretty small part of the hole shebang.

Exactly.  Moreover. Note that EcoLISP by Beppe Attardi
(ftp://ftp.icsi.berkeley.edu/pub/ai/ecl)
already contains a continuation passing threading machinery.

Moreover, allow me to stress that the "non-paucity" of Scheme
implementations is not a "good thing" per se.

   o The Scheme folks really hate it.

This is the least important of the objections that can be made.  Apart
from the standard critiques of Scheme (non standard as soon as you
step out of RxRS, hack prone - a bad quality - etc), there is the
simple fact that the main services of a Lisp OS (mostly GC and IPC)
are common to Scheme and CL and independent of the higher level
language.

   BTW, a couple of folks have advocated using call/cc over stack groups.
   I don't understand this.  Assuming we want a traditional thread
   scheduler (we do, don't we?), you still have to have all the API cruft
   to register continuations and manage priorities.  How do you deal with
   continuations in the presence of dynamically scoped exception
   handlers?  And what about locking?

Scheme does not have an exception (i.e. CONDITION) system - at least
last I checked.  This alone should make the decision to choose Scheme as
the Lisp OS language a little less desirable.

Having said so, I really want to stress that whatever the end result,
any process that will lead there will be successful as long as it does
not try to reinvent anything new.  I don't see a Sun sponsoring a
language group that has control over the design of "something new".  I
see two Lisp dialects widely accepted which share a common substrate
which can be made independent of the top level language.  This is what
a Lisp OS should be built upon.

Cheers

Marco Antoniotti

PS.
The fact that CL will then be seen as a better alternative to higher
level of programming will come by itself when the needs for a standard
(if not perfect) package system, object system and exception system
will be properly understood.