Language peer sets for Scheme 48:
United States↑
United States/1978↑
Designed 1978 ↑
1970s languages ↑
Fourth generation↑
High Cold War↑
Genus Lazy Evaluation FPs ↑
String and List Processing ↑
Lazy Evaluation FPs↑
FPs↑
Lambda caculus ↑
Lazy Evaluation FPs/1978↑
FPs/1978↑
Lambda caculus/1978↑
Lazy Evaluation FPs/United States↑
FPs/United States↑
Lambda caculus/United States↑
String and List Processing ↑
String and List Processing/1978↑
String and List Processing/us ↑
Scheme 48 (7199/sch016) |
 |
Country: United States
Designed 1978
Genus: Lazy Evaluation FPs
Sammet category: String and List Processing
Simplified version of Scheme, written in 48 hours (hence title)
Rees and Johnson
Used to create Scsh (SCheme SHell)
People:
Related languages
| Scheme | → | Scheme 48 | Implementation | |
| Scheme 48 | → | Hotdog | Port | |
| Scheme 48 | → | scsh | Built with |
References:
in (1985) European Conference on Computer Algebra EUROCAL 85 LNCS 204
in (1985) European Conference on Computer Algebra EUROCAL 85 LNCS 204
Resources
-
Scheme 48 unofficial home page Early history: The toy
The Scheme 48 'project' began in August 1986. It was the result of a conversation between Richard and Jonathan immediately following the 1986 Lisp and Functional Programming Conference in which we considered the question "why do Lisp/Scheme implementations always become so complicated?".
Within 48 hours we had designed and implemented a working Scheme, including read, write, byte code compiler, byte code interpreter, garbage collector, and initialization logic.
Our hacking time together was limited since Richard had to return to New Haven. The name we chose was a nod to a 1982 film by Walter Hill, as well as a nod to another Scheme implementation known as Scheme 84.
The design, as it elaborated over the next couple of years, was in many ways a reaction to other systems of the 1980's that we had been using and/or working on, including
T and Orbit, which we felt had gotten a bit out of control (is there a T web page? Just Olin's history, I suppose)
The MIT/LMI/Symbolics Lisp machine - JAR felt you could make something with many of its positive properties for a fraction of the complexity. Whether Scheme 48 actually did this is not clear.
MIT Scheme, which started simple and became complex
The Scheme chips of Sussman et al. at MIT, which stayed pretty simple
MacScheme (Will Clinger's Scheme for the Apple Macintosh), probably the most similar in architecture of any system with which we were familiar
For the first year or so the sources lived on an ITS file system and saw some development by JAR. The system ran under Common Lisp on the Symbolics 3600, as well as under Maclisp on the PDP-10, using various sets of macros that gave these Lisps a Scheme-like syntax. This was not 'incestuous' since the part of the system executed by the underlying Lisp (the virtual machine, or VM) was carefully written in such a way that it in principle it did not need a garbage collector, tail recursion, or other Lisp-specific apparatus; it was really a C or assembly-level program with Lisp syntax. Scheme 48's Lispy implementation language (LIL - an adjective coined at MIT in the 1970's) was later dubbed 'Pre-Scheme'.
In December 1987 we sent sources to Ozan Yigit, who was curious about it. This may have been the first 'release'. A mailing list was created at ai.ai.mit.edu for interested observers that included Alan Bawden, John Wroclawski, Will Clinger, Norman Adams, and others.
In 1988-89 [?] Richard was working on Scheme 48 at Yale, using T as the platform. He wrote the first compiler for Pre-Scheme, based on his dissertation work. Until this time, the virtual machine (eval + GC) ran only as a Lisp program (except see re Bob Brown, below). Since the compiler targeted C, we now had a way to create high-performance virtual machines for Scheme 48.
Later history: A useful thing
In summer 1990 JAR did some work on Scheme 48 at Xerox PARC. This is where the bignum code and generic arithmetic code started. JAR has a habit of writing code in such a way that he can can amuse himself and maybe learn something, and about 75% of the time these experiments have rather awful outcomes.
In 1991-92 JAR hacked intensively on Scheme 48 so that it could maintain a common code base with the mobile robot system. This was the origin of the module system, which started as an attempt to do as little invention as possible, and simply rationalize and Schemize Common Lisp's defpackage, with a dash of ML modules thrown in to make it interesting. The modules started out as lists of files, some of which belonged to the cross-compilation system, some to the interpreter, and some to the "run-time system" (auxiliary Scheme code such as read that is byte-compiled and subsequently byte-interpreted). I introduced new modules as necessary so as to carve the system into parts to be built into the mobile robot system, those to go into the teledebugging system, those to go into the full non-robot system, and those to go into the various overlaps of these destinations. For a long time it was enough for the module system to keep track of which files were to be loaded into the global namespace, but eventually the module system acquired a notion of interface and provided namespace separation.
[22 April 2003] I also had to introduce a system of integer identifiers to name various bits of debugging information, such as procedure names, correspondence between continuations and source code, etc. The robot knew the id's but not the textual information, which was kept on the other end of the 'tether' in the teledebugging system. This was the source of some bewildering and poorly documented complexity in the 'linker' (the thing that built heap images from scratch) and system bootstrap logic.
One feature I liked that was preserved at least until 1993 was the ability to bootstrap the system from systems other than Scheme 48. It was possible at that time to use the byte code compiler and static linker to build the initial heap image using either Lucid Common Lisp (with Pseudoscheme for making Common Lisp pretend to be Scheme) or Scheme-to-C.
The earliest numbered version of Scheme 48 that I could find when I looked in late 2002 was version 0.20, made in May, 1993 (at Cornell). For version numbering I simply used the ITS convention of incrementing the version on every build, so the number rose quickely. The '0.' on the beginning was both a disclaimer and wishful thinking.
Richard has had the lock on the sources since fall 1993. He worked on Scheme 48 at NEC Research Institute for many years, and among innumerable other improvements, wrote a new thread system based on re-entrant schedulers that provides non-blocking I/O and an optimistic concurrency mechanism.
Richard has also worked on native code compilers for Scheme 48, but these projects have not yet found their way into the distribution.
- Official Scheme 48 page
Search in: Google Google scholar World Cat Yahoo Overture DBLP Monash bib NZ IEEE ACM portal CiteSeer CSB ncstrl jstor Bookfinder