| <<< TLE::PUBD$:[VAXNOTES]LANGUAGES.NOTE;1 >>>
-< Languages >-
================================================================================
Note XXX List of scheme implementations No replies
AITG::JAR 418 lines 8-JAN-1988 11:49
--------------------------------------------------------------------------------
Scheme implementations
Compiled by Jonathan Rees on 15 November 1985, updated 27 December 1987.
Send inquiries about the [email protected] mailing list to
[email protected].
The "Revised^3 Report on the Algorithmic Language Scheme" is in SIGPLAN
Notices 21(12), December 1986. It can also be ordered from:
Elizabeth Heepe
Publications, Room NE43-818
MIT Artifical Intelligence Laboratory
545 Technology Square
Cambridge MA 02139
Ask for MIT AI Memo 848a, and enclose a check for $6.00 per copy (U.S.
funds) payable to the MIT Artificial Intelligence Laboratory.
(This report supersedes the "Revised Revised Report on Scheme", but the
differences in the language between the two versions are not major.)
Implementation: MacScheme, MacScheme+Toolsmith
Implemented by: Will Clinger, John Ulrich, Liz Heller, and Eric Ost
Supported by: Semantic Microsystems
Hardware: Apple Macintosh, Macintosh Plus.
Requires 512K bytes RAM.
1024K recommended for MacScheme+Toolsmith.
Operating Systems: Finder (Macintosh).
Price/Availability: $125 for basic system; available since August 1985.
$250 (introductory price) for MacScheme+Toolsmith;
available since December 1986.
Implementation: Compiles to interpreted byte code.
Intended Use: Education, personal computing, AI applications
Contact: Semantic Microsystems
4470 S.W. Hall St., Suite 340
Beaverton, OR 97005
(503) 643-4539
MacScheme supports all essential and most optional features of the
Revised^3 Report on the Algorithmic Language Scheme. It includes a
compatibility package for use with "Structure and Interpretation of
Computer Programs" by Abelson and Sussman. Approximately 15 universities
and colleges currently use MacScheme in their courses.
MacScheme includes facilities for breaking, tracing, and debugging. Most
run-time errors can be repaired in the debugger. Numbers are implemented
as a union of 30-bit fixnums, bignums, and 32-bit flonums; bignum arithmetic
is slow. Procedures are provided for pretty-printing and sorting.
The system includes a simple editor that understands Scheme syntax and
makes good use of multiple windows and the mouse. This editor runs as a
foreground process while Scheme runs in the background. Simple graphics
are included in the basic system, together with an escape to machine code
for direct access to the Macintosh Toolbox.
MacScheme+Toolsmith adds very high-level support for interactive menus,
windows, and text editors, high-level support for Macintosh file i/o,
and a comprehensive library of type declarations and Scheme procedures
for calling the low-level Toolbox traps described in Inside Macintosh.
MacScheme+Toolsmith also features multi-tasking and a versatile interrupt
system for handling events. Scheme source code is provided for the
standard interrupt handlers and high-level objects, together with several
examples that show how to program standard features of the Macintosh user
interface.
The ResEdit graphical resource editor is included with MacScheme+Toolsmith.
Complete applications can be dumped as "double-clickable" heap images,
from which unused procedures (the compiler, for example) have been removed
through selective linking.
[1-7-87]
Implementation: PC Scheme
Developed by: Texas Instruments Computer Science Lab
Supported by: Texas Instruments Digital Systems Group
Hardware: TI Professional and TI Business-Pro Computers,
IBM PC, PC/XT, PC/AT and IBM compatibles
Operating Systems: MS(tm)-DOS 2.1 (PC-DOS) or better (at least 320K, dual
floppy)
Price/Availability: List price - $95
Implementation: Incrementally compiled to byte-codes
Intended Use: Education, research, and support of AI software on PCs
PC Scheme is an implementation of Scheme for the TI Professional
Computer and IBM(r) Personal Computer families. The product
consists of an optimizing compiler, a byte-code interpreter, extensive
run time support, an interactive, display-oriented editor, a language
reference manual, and a user's guide. The system was developed on the
TI Professional Computer in Scheme itself, with critical run time
routines coded in C and assembly language for increased performance.
PC Scheme provides all the essential and most of the optional features
of the Revised Revised Report on Scheme. It fully supports the
dialect used in the book "Structure and Interpretation of Computer
Programs" by Abelson and Sussman as well as many extensions developed
at Indiana University, MIT, and TI. These include first-class engines
and environments and an experimental, object-oriented programming
system with dynamic multiple inheritance called SCOOPS. Data type
support includes symbols, lists, vectors, strings, fixnums, bignums,
flonums (64 bit IEEE floating point), characters, closures,
continuations, environments, and I/O ports.
Evaluation is based on incremental compilation to byte-coded "virtual
machine" code which is emulated using threaded code techniques.
Informal benchmarks, including some of the Gabriel set, show PC Scheme
programs to be about 3-10 times faster than interpreted IQLISP(tm) and
2-4 times faster than interpreted Golden Common LISP(tm).
To order, write to Texas Instruments, 12501 Research Blvd., MS 2151,
Austin, TX 78759 and ask for TI Part number #2537900-0001. You may also
order by telephone using MasterCard or VISA by calling 1-(800)-TI-PARTS.
Questions or comments on the product may be directed to the address
given above. We also welcome less formal technical questions and
comments, which may be directed via CSNET to Oxley@TI-CSL.
[11-12-85]
Implementation: Chez Scheme
Written by: Kent Dybvig and Bob Hieb
Supported by: Cadence Research Systems
Hardware: VAX (VMS, Ultrix, 4.2 or 4.3 BSD UNIX), Sun-3 (SunOs),
Apollo (Domain/IX), and Alliant (Concentrix)
Implementation: incrementally compiled to native code
Intended Use: education, research, systems development
Price: ranges from $1500 for one machine to $12,000 for site
educational institutions receive 50% discount
Chez Scheme was first released in early 1985, and is in use at several
dozen sites. Now in its second major released version, it supports all of
the required features of the R3RS, and all but one or two optional features.
It also supports all of the features in The Scheme Programming Language. It
features an incremental optimizing compiler with variable optimization
levels.
In addition to the features of the RRRS, Chez Scheme provides programmable
error and exception handlers, engines, programmable cafes and waiters (fancy
read-eval-print loops), tracing and statistics-gathering facilities, a
high-level syntax-specification facility (extend-syntax), and fast-loading
compiled files. Chez Scheme provides floating point numbers and arbitrary-
precision ratios and integers, but no imaginary numbers at present.
Most of our development time has been spent making the implementation as
as reliable and as efficient as possible. In making the system efficient,
we have concentrated on memory and disk utilization and storage management
as well on as compiler speed and speed of generated code. For example, the
initial load image for the VAX is under 3/4 megabyte, of which all but 1/4
megabyte is read-only and sharable. Working-set size is typically under
1/2 MB per process for many applications.
For information contact:
Sue Rykovich
Cadence Research Systems
620 Park Ridge Road
Bloomington, IN 47401
812/333-9269
You can also request information through Kent Dybvig at [email protected]
(include physical mailing address).
[10-30-87]
Implementation: SIOD (Scheme In One Defun)
Implemented by: George Carrette (GJC@MIT-MC)
Contact: GJC@MC
Support: GJC, for use in LMI lisp classes.
Hardware: LMI-LAMBDA, ZETA(FOO?)LISP.
Availability: Given out at my "guest lectures" to LMI lisp classes.
Dialect: Sufficient to run S&ICP problems I find most interesting.
Especially streams, the meta-linguistic abtraction section,
and the interpreter/hardware sections.
Intended use: Education. Both to introduce S&ICP and to show interpreter
implementation, also "WHY MACROS OR BAD, or WHY CANT YOU READ
MY CODE?"
Implementation: The function SEVAL (scheme EVAL) is one DEFUN.
The "text" being interpreted is syntax-checked first, but is otherwise
just the obvious s-expression. The environment representation is an ALIST.
Because of the underlying simplicity it was possible to code
special cases such as look-ahead for simple variable lookup,
and primitives such as +,/,CAR,CDR, applied to simple variable lookups
without fear. There is very little overhead in the interpreter besides
variable lookup (a single instruction, %ASSQ) and environment consing,
(cheaper by the dozen and with the volatility based GC). The resulting
interpreter is somewhat gross because of its use of specialized
macrology, but is extremely fast, especially when compiled into
MICROCODE by the Microcompiler.
Remarks: One reason for this was to see just how far a few hours work
on a simple idea implemented somewhat grossly could go. Whenever I was
too burned out to do design-level work or debugging work (presumably on
jobs that I was paid to do) I might feel like trying to code
another SIOD special case. It is also a study for "how much effort should
go into avoiding CONS, vs other things?" It could be interesting to
compare its efficiency with JAR's compiler-style CLSCH.
[10-28-85]
Implementation: Scheme84
Scheme84 is a version of Scheme that has been under development at
Indiana University for the past few years, and is used there to support
half a dozen different computer science courses. The system runs on the
Vax under either VMS or Berkeley Unix. The developers of Scheme84
intend to supply a compatibility package that will allow the MIT
materials to be run without modification. The Scheme84 software is in
the public domain, and can be obtained by writing to
Scheme84 Distribution
Nancy Garrett
c/o Dan Friedman
Department of Computer Science
Indiana University
Bloomington, Indiana
(812)-335-9770
E-mail address nlg@indiana
The current distribution policy for Scheme84 is that Indiana University
will supply it for free, if you send them a tape and return postage.
(Please specify whether the system is to be for VMS or for Unix.) On
the other hand, the University reserves the right to begin charging a
fee to recover the cost of distribution, should this become necessary.
[early 1985?]
Implementation: T
T is a version of Scheme that was developed at Yale University, and is
available for distribution. The system runs on Vaxes under Unix
(4.2bsd) and on Motorola 680x0 systems (Apollo Domain, Sun, HP
9000/300). Although the default environment is the T programming
language, an environment comforming to the Revised^3 Report on Scheme is
also available.
A new version of T (version 3.0) was released in January 1987. This
includes the optimizing compiler described in a paper by Kranz et al.
in the Proceedings of the 1986 SIGPLAN Compiler Construction Conference.
T is available via Internet FTP. Connect to host PREP.AI.MIT.EDU,
log in as user scheme password scheme, and get the appropriate compressed
tar files from the directory /t:
readme.tar.Z installation and release notes
hp.tar.Z executable image for HP-UX
sun.tar.Z executable image for SUN
vax_unix.tar.Z executable image for VAX running 4.2BSD or Ultrix
sources.tar.Z source code for compiler and runtime system
If you can't get T this way, try to get it from someone who has it, or,
as a last resort, Yale will mail you a tape for $200 (?).
For more information, contact Jim Philbin at Yale ([email protected],
203-432-1266) or write to
T Project
Yale University Dept. of Computer Science
PO Box 2158
Yale Station
New Haven, CT 06520
[1-16-87]
Implementation: Vincennes Scheme
Vincennes Scheme is a version of Scheme written entirely in portable
C, for Unix V7 and Berkeley 4.1 and 4.2. It runs on 32-bit machines
(e.g. 68K or Vax) as well as on 16-bit machines (e.g. Z8000 in which
it can fit in 128K). This Scheme is compatible with the MIT version,
and includes an interpreter with the basic environment: debugger,
history, break, stepper, where. A compiler that generates C code is
available. For more information, contact
Patrick Greussay
Universite Paris-8-Vincennes
2 rue de la Liberte
Saint-Denis CEDEX 02 93526
France
[early '85?]
Implementation: Pseudoscheme (Scheme embedded in Common Lisp)
Implemented by: Jonathan Rees
Support: Unsupported, although I'll probably continue to improve it.
Hardware, etc.: Will run in any implementation of Common Lisp.
Availability: Free. Distributed as source via electronic mail or
FTP. (I won't make tapes.)
Dialect: Subset. Tail-recursion is not supported except in the
special case that a loop is found statically, which is
when the loop is written explicitly using LETREC or
something that expands into LETREC (DO, named LET,
internal DEFINE). Tail-recursion will of course be
inherited from the host Common Lisp if it has it.
All of the essential features of R^3 Scheme exist,
except for a correct CALL-WITH-CURRENT-CONTINUATION (some
of you will say that it's not Scheme at all, and I don't
disagree) and number exactness; most of the non-essential
features are there too, and a few things needed to run
code from S&ICP.
Intended use: Running Scheme programs using any Common Lisp.
Implementation: A preprocessor translates Scheme code into Common Lisp
code, which is then interpreted or compiled by the host
Common Lisp system. The source code seems to work well,
but it's unclean.
Remarks: I did this mostly for my own personal use. Maybe other
people will find it useful too.
Contact: Jonathan Rees ([email protected]), MIT Artificial
Intelligence Laboratory, 545 Technology Square, Cambridge
MA 02139, (617) 253-8581.
[2-27-86]
Implementation: MIT Scheme
There are currently 2 implementations of MIT Scheme:
"Gator" Scheme runs on HP 9000 series 200 (and old model 9836 plus
variants) computers under the Pascal 3.1 operating system. It is
quite dependent on this operating system and the tools provided with
it. This is currently our main implementation. Most of the code is
written in Scheme, but the interpreter and support procedures
(operating system interface) are written in assembly language
(Motorola 68000) and Pascal (HP dialect). There is a very
idiosincratic compiler (Liar) in this version which with motherly care
or luck can give very good performance, but which will not perform so
well without pampering. There is also a very good editor (Edwin)
written in Scheme. It is very similar to GNU Emacs, but its interface
to Scheme is (for obvious reasons) better.
CScheme (pronounced like "see-scheme") runs on a variety of machines
which have C compilers. In particular, it runs on Vaxen (both BSD4.2
Unix and VMS), various flavors of Unix (HP-UX, Sun BSD), and is quite
portable, but may require some work on "strange" machines and/or
operating systems. This version (the interpreter and support
routines, which are written in C) was originally written to illustrate
how a Scheme system could be built, not as a "production" version.
Its main emphasis was clarity, rather than efficiency. As of late,
with (slowly) increasing efficiency and use, it is becoming the base
for a variety of projects. Its performance is adequate (although not
great) on the latest generation single user workstations (Suns, HP
9000 series 300, etc). There is currently no compiler for this
version. There is a moderately good (although not perfect) interface
to GNU Emacs, and a barely adequate interface to DEC Emacs for VMS.
Both systems are pretty similar as far as "normal" users are concerned
(the systems share the code written in Scheme although they are
currently somewhat out of phase). Both versions also require large
amounts of memory (upwards of 4 Mb for Gator Scheme with all the
features, somewhat over 2 Mb for Cscheme).
Within the next few months (by September '86 probably) we will shift
from Gator Scheme to CScheme (CScheme will become our main
implementation), and there will be a (new) compiler for CScheme with
back ends at least for the common machines (68k family and Vax).
Eventually we plan to have a C back end also (does anybody know of a
portable dynamic loader for C/Unix ?). Edwin will also be ported to
CScheme (at least under versions of Unix providing the curses(3)
library).
For more information about either version, send (arpa) mail to
SCHEME-TEAM%MIT-OZ@MIT-MC
or US Snail to
Scheme Team
c/o Prof. Hal Abelson
545 Technology Sq. rm 410
Cambridge MA 02139
For particular information about CScheme, send mail to
INFO-CSCHEME%MIT-OZ@MIT-MC (send mail to info-cscheme-request to be
added to this mailing list)
To obtain a copy of MIT Scheme
1) If you want CScheme, and have access to the arpanet, a "tar" file
(for Unix) exists on MIT-PREP /scheme/dist.tar . There is usually a
"compressed" (dist.tar.Z) file also. If the file does not exist for
any reason, log in (via telnet) to MIT-PREP as scheme (no password).
The files will be re-generated by the log in program.
2) If you can use ftp over the arpanet, but cannot use a tar file, get
in touch with us describing what version you want, and we may be able
to arrange some way to get the sources across the net.
3) Otherwise, try to get a copy from someone who already has it.
4) As a last resort (unadvisable), send $200 to the address above, and
specify what form of tape you want. We can currently provide
1600 bpi standard tar tape.
1600 bpi standard VMS backup tape.
HP-UX cartridge tar tape.
[4-1-86]
From: harvard!ut-sally!uunet!mcvax!litp!ald at bbn.com
Organization: L.I.T.P, Universite P7, PARIS
Name: skim (a low fat implementation of Scheme)
Authors: A. Deutsch, R. Dumeur, C. Consel, J.D. Fekete.
Runs-on: Sun[23], Vax, Orion under BSD Unix.
Has: An interpreter and a compiler (vax only for now).
Features:
- R3RS compatibility (but misses complex, bignums and ratios);
- extensible type system and operations;
- stop/copy gc;
- scode based interpreter.
Availability:
- the system has been registered;
- binaries are available (we do not plan to distribute sources now).
Performance:
- the interpreter is quite fast (5 times faster that MIT-scheme).
- the compiler is not an optimizing compiler.
Contact:
- ...mcvax!inria!litp!{ald|chac|jdf|red}
[12-27-87]
|