[Top][All Lists]

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

SIOD begat SCM begat Guile begate Systas

From: Tom Lord
Subject: SIOD begat SCM begat Guile begate Systas
Date: Wed, 25 Jul 2001 04:49:54 -0700 (PDT)

Systas has evolved in ways mostly orthogonal to the ways that Guile
has evolved, though some incompatabilities have arisen.

Perhaps this will be of interest.  On the upside, there's some
libraries in Systas that should port easily, and perhaps an
opportunity to merge some features.  On the downside, see the
enclosed notes about the garbage collector.


A new release of Systas Scheme, an interpreter that branched from
Guile a few years ago, is now available at "";.

The largest change in this release is the inclusion of a reference
manual.  Like Systas itself, the reference manual is far from
polished, but useful.

Below is an outline that describes Systas Scheme.  The topics in
the outline are:

   * Systas Extensions to the Scheme language
   * Features for Unix Systems and Shell Programming
   * Additional Libraries and Built-ins
   * Some Quite Raw But Interesting Features
   * Some Requirements That Define Systas Scheme
   * Some Possible Requirements for Systas Scheme
   * Most Noteworthy Problems With the Implementation

The reference manual (available on the web site and in the tar-ball)
has additional information about the state of Systas.

The aspects of Systas which I am the most pleased about are also 
the hardest to convey in an outline or reference manual:  First, I've
put a substantial amount of effort into polishing the interfaces
to various Scheme libraries so that they work nicely together
and "feel consistent".  Second, even though Systas is fairly large,
I've put a substantial amount of effort into keeping it as minimal
as practical.  Much more could be done in these directions, but a lot
has been done already.

Systas is Free Software, covered by the GNU GPL. 


* Systas Extensions to the Scheme language

** Symbols can usually be used as strings

   Most procedures that accept strings, but that don't modify those
   strings, can accept symbols.

** Space-efficient shared substrings are provided

** First-class keyword objects are provided

   Keywords are handy for options and named optional arguments to

** Weak vectors and hash tables are provided

   But see the warnings, below, about the garbage collector.

** A very simple, yet quite general implementation of 
   structures is provided

   The aim was to provide a structure type that was simple and clean,
   yet which could be used to implement all the popular record types
   and object systems.

** First-class variables (locations) are available

** Systas has support for exceptions.  

   There are two kinds of exception handler and two ways to throw
   exceptions, depending on whether or not the exception is resumable.

** Systas has a simple, powerful module system.

   One nice feature of the module system is that (if you also grab my
   elisp library) it works well with Emacs for interactive,
   incremental program development.

* Features for Unix Systems and Shell Programming

** Ports and file descriptor objects are the same thing.

   Systas has first-class file descriptor objects and uses an I/O
   library that allows descriptors to be optionally buffered.
   Buffered descriptors and Scheme ports are the same thing.

** All but the most obscure unix system calls are 
   available as built-in procedures.

   System calls return symbols (e.g. 'ENOENT) to indicate errors.  If
   you'd rather have exceptions, there is a simple mechanism for that,

** There is an SCSH-like library provided

   The primary difference between our library and SCSH is that in
   SCSH, process forms are translated to code by macros.  In Systas,
   process forms are interpreted at run time.  Our approach allows
   process forms to be constructed on-the-fly as a program runs.

** There is a find-like directory searching library

** There is a library of procedures for manipulating file names.

* Additional Libraries and Built-ins

** SRFI-14, "Character-Set Library" is provided.

** SRFI-1, "List Library" is provided.

** FPS, "Functional Postscript" is provided.

** An original library of fancy string manipulation functions
   is provided.

   This library makes good use of shared substrings.

** The Rx regexp library is available.

   We provide a very nice interface to regexec.  We also provide
   access to some of Rx's non-standard features.

** An original take on structured regexps is provided.

* Some Quite Raw But Interesting Features

** There is document formatting system.

   This code extracts documentation from comments in C code and
   produces HTML or Texinfo.  The mark-up language used by this system
   is extremely unobtrusive -- the comments needn't be cluttered with
   excessive markup syntax.

* Some Requirements That Define Systas Scheme

  Systas Scheme will most likely change quite a bit in the future.  It
  might, for instance, be replaced with a completely new
  implementation.  However it changes, we think these requirements are
  likely to constrain the implementation:

** Good interactive performance

   We want `eval' to be fast.

** Space-efficient cons pairs

   The proper size of a cons pair is (2 * sizeof (void *)).

** A simple, interactive module system that works well with Emacs

** Good integration with unix

** Good I/O performance

** Shared substrings and symbols-as-strings

** Good Debugging Support

** Robust, efficient, modular GC

** Free Software (GPL, with no special exceptions)

* Some Possible Requirements for Systas Scheme

** A better, underlying C library.

   The basic Scheme types and GC should be part of the C library,
   available even to programs that don't use a complete Scheme

** An imperative, statically typed subset.

   Systas should have such a thing -- perhaps a simple subset of Java.
   The purpose of this subset is to support programs that can be
   easily compiled to very efficient native or VM code.

** Purely functional subsets.

   It might be nice to have some functional languages, both eager and
   lazy, sharing data and run-time systems with Scheme.

* Most Noteworthy Problems With the Implementation

** Systas has been developed poorly

   The software engineering practices that led to Systas 
   have been fairly sloppy.  I presume it has plenty of bugs,
   but its difficult to know how many, because testing has
   been inadequate. 

** Systas relies upon a broken garbage collector

   Like the interpreters from which it branched, Systas
   uses a GC that conservatively scans the C stack.
   Such collectors are fundamentally broken -- they can
   cause storage leaks that are unpredictable, and 
   irreparable.  Don't run your spaceship navigation
   system on this interpreter.

   Unfortunately, fixing this is difficult.  Nearly 
   every function in the implementation relies on the
   conservative nature of the GC.

** There isn't a compiler available

** It's probably slow

   I haven't run benchmarks, because I haven't tuned the
   interpreter in several years.  I'd guess it compares 
   poorly to other interpreters in this respect.

** No debugger is provided

   Some low-level debugging support is there, but nothing
   that works usefully.

** The implementation hasn't been widely ported for several years.

   I develop Systas on a FreeBSD system, and sometimes test it on Linux.

reply via email to

[Prev in Thread] Current Thread [Next in Thread]