FAQ: Scheme Frequently Asked Questions 1/2 [Monthly posting]

0 views
Skip to first unread message

Mark Kantrowitz

unread,
Jul 13, 1997, 3:00:00 AM7/13/97
to

Archive-name: scheme-faq/part1
Last-Modified: Wed Apr 30 14:13:24 1997 by Mark Kantrowitz
Version: 1.30
Maintainer: Mark Kantrowitz and Barry Margolin <ai+li...@cs.cmu.edu>
URL: http://www.cs.cmu.edu/Web/Groups/AI/html/faqs/lang/scheme/top.html
Size: 56149 bytes, 1157 lines

;;; ****************************************************************
;;; Answers to Frequently Asked Questions about Scheme *************
;;; ****************************************************************
;;; Written by Mark Kantrowitz and Barry Margolin
;;; scheme_1.faq

This post contains part 1 of the Scheme FAQ.

If you think of questions that are appropriate for this FAQ, or would
like to improve an answer, please send email to us at ai+li...@cs.cmu.edu.

Note that the lisp-faq mailing list is for discussion of the content
of the FAQ posting only. It is not the place to ask questions about Scheme;
use either the sch...@ai.mit.edu mailing list, the comp.lang.scheme
newsgroup or the Scheme Digest (sch...@mc.lcs.mit.edu) for that. If a
question appears frequently in one of those forums, it will get added
to the FAQ list.

*** Copyright:

Copyright (c) 1993-94 by Mark Kantrowitz and Barry Margolin.
All rights reserved.

This FAQ may be freely redistributed in its entirety without
modification provided that this copyright notice is not removed. It
may not be sold for profit or incorporated in commercial documents
(e.g., published for sale on CD-ROM, floppy disks, books, magazines,
or other print form) without the prior written permission of the
copyright holder. Permission is expressly granted for this document
to be made available for file transfer from installations offering
unrestricted anonymous file transfer on the Internet.

If this FAQ is reproduced in offline media (e.g., CD-ROM, print form,
etc.), a complimentary copy should be sent to Mark Kantrowitz, School
of Computer Science, Carnegie Mellon University, 5000 Forbes Avenue,
Pittsburgh, PA 15213-3891 USA.

This article is provided AS IS without any express or implied warranty.

*** Topics Covered:

Topics Covered (Part 1):
[1-0] What is the purpose of this newsgroup?
[1-2] What is the difference between Scheme and Common Lisp?
[1-3] Scheme books, introductions, documentation, periodicals,
journals, and conference proceedings.
[1-4] Where can I learn about implementing Scheme interpreters and
compilers?
[1-7] Standards for Scheme -- What are R4RS and IEEE P1178?
[1-8] How do I do object-oriented programming in Scheme?
[1-9] Repositories of Scheme Software
[1-10] Publicly Redistributable Scheme Software
[1-11] Formatting code in LaTeX (WEB and other literate programming tools)
[1-12] Where can I get an implementation of Prolog in Scheme?
[1-13] What does SICP, SCOOPS, R4RS, CAR, CDR, ... mean?
[1-14] Why is there no EVAL in Scheme?
[1-15] World-Wide Web (WWW) Resources
[1-16] Why is Scheme called 'Scheme'?

Topics Covered (Part 2):
[2-1] Free Scheme implementations.
[2-2] Commercial Scheme implementations.
[2-3] What Scheme-related discussion groups and mailing lists exist?

Search for \[#\] to get to question number # quickly.

*** Recent Changes:

;;; 1.19:
;;; 20-OCT-94 mk Added FTP location for Scheme84.
;;; 3-NOV-94 mk FTP collections on altdorf.ai.mit.edu have moved to
;;; swiss-ftp.ai.mit.edu
;;; 3-NOV-94 mk Added Christian Queinnec's Lisp book to [1-4].
;;;
;;; 1.20:
;;; 15-NOV-94 mk Updated location of Ken Dickey article.
;;;
;;; 1.21:
;;; 22-NOV-94 mk Scheme Repository at Indiana University WWW page.
;;; 7-DEC-94 mk Updated EdScheme entry in [2-2].
;;;
;;; 1.22:
;;; 16-JAN-95 mk Updated Schemers entry.
;;; 31-JAN-95 mk Added Manis' book to [1-3].
;;;
;;; 1.23:
;;; 13-MAR-95 mk Updated EdScheme and 3DScheme for Windows in part 2.
;;; 7-APR-95 mk Added Scsh entry provided by Olin Shivers to [2-1].
;;;
;;; 1.24:
;;; 14-APR-95 mk Updated description of the Schemer's Guide.
;;;
;;; 1.25:
;;; 13-JUL-95 mk Updated 3d-Scheme entry in part 2.
;;;
;;; 1.26:
;;; 17-AUG-95 mk Updated ELK entry in part 2.
;;; 11-SEP-95 mk Updated EdScheme and 3DScheme for Windows entries in part
;;; 2.
;;; 19-FEB-96 mk Updated Schemer's entry in part 2.
;;; 19-MAR-96 mk Added entry on comp.lang.scheme.scsh to part 2.
;;; 13-NOV-96 mk Added entry for MzScheme.
;;; 30-APR-97 mk Added Inlab Scheme to [2-2].

*** Introduction:

Certain questions and topics come up frequently in the various network
discussion groups devoted to and related to Scheme. This file/article is
an attempt to gather these questions and their answers into a convenient
reference for Scheme programmers. It (or a reference to it) is posted
periodically. The hope is that this will cut down on the user time and
network bandwidth used to post, read and respond to the same questions
over and over, as well as providing education by answering questions
some readers may not even have thought to ask.

This is not a Scheme tutorial, nor is it an exhaustive list of all Scheme
intricacies. Scheme is a very powerful and expressive language, but with
that power comes many complexities. This list attempts to address the
ones that average Scheme programmers are likely to encounter. If you are
new to Scheme, see the answer to the question "How can I learn
Scheme?" [1-3].

The latest version of this file is available via anonymous FTP from CMU:

To obtain the files from CMU, connect by anonymous FTP to
ftp.cs.cmu.edu:/user/ai/pubs/faqs/scheme/ [128.2.206.173]
using username "anonymous" and password "name@host" (substitute your
email address) or via AFS in the Andrew File System directory
/afs/cs.cmu.edu/project/ai-repository/ai/pubs/faqs/scheme/
and get the files scheme_1.faq and scheme_2.faq.

You can also obtain a copy of the FAQ by sending a message to
ai+q...@cs.cmu.edu with
Send Scheme FAQ
in the message body.

An automatically generated HTML version of the Scheme FAQ is accessible by
WWW as part of the AI-related FAQs Mosaic page. The URL for this
resource is
http://www.cs.cmu.edu/Web/Groups/AI/html/faqs/top.html
The direct URL for the Lisp FAQ is
http://www.cs.cmu.edu/Web/Groups/AI/html/faqs/lang/scheme/top.html

We've tried to minimize the overlap with the FAQ postings to the
comp.lang.lisp, comp.lang.clos and comp.ai newsgroups, so if you don't
find what you're looking for here, we suggest you try the FAQs for
those newsgroups. These FAQs should be available by anonymous ftp from
rtfm.mit.edu:/pub/usenet/news.answers/ [18.181.0.24]
in the lisp-faq/, ai-faq/ and scheme-faq/ subdirectories or by email.
For instructions on email retrieval, send a mail message to
mail-...@rtfm.mit.edu with "help" and "index" on separate lines in
the body of the message.

If you need to cite the FAQ for some reason, use the following format:
Mark Kantrowitz and Barry Margolin, "Answers to Frequently Asked
Questions about Scheme", comp.lang.scheme, <month>, <year>,
ftp.cs.cmu.edu:/user/ai/pubs/faqs/scheme/scheme_?.faq,
ai+li...@cs.cmu.edu.

----------------------------------------------------------------
Subject: [1-0] What is the purpose of this newsgroup?

The newsgroup comp.lang.scheme exists for general discussion of
topics related to the programming language Scheme. For example, possible
topics can include (but are not necessarily limited to):
announcements of Scheme books and products
discussion of programs and utilities written in Scheme
discussion of portability issues
questions about possible bugs in Scheme implementations
problems porting an implementation to some architecture
Postings should be of general interest to the Scheme community. See also
question [2-3].

The comp.lang.scheme newsgroup is archived in
ftp.cs.cmu.edu:/user/ai/pubs/news/comp.lang.scheme/
on a weekly basis.

Questions about Common Lisp should be directed to the newsgroup
comp.lang.lisp. Discussion of object oriented programming in Lisp to
the newsgroup comp.lang.clos. Discussion of functional programming
language issues in general should be directed to the newsgroup
comp.lang.functional. Discussion of AI programs implemented in Scheme
should sometimes be cross-posted to the newsgroup comp.ai.

----------------------------------------------------------------
Subject: [1-2] What is the difference between Scheme and Common Lisp?

Scheme is a dialect of Lisp that stresses conceptual elegance and
simplicity. It is specified in R4RS and IEEE standard P1178. (See
question [1-7] for details on standards for Scheme.) Scheme is much
smaller than Common Lisp; the specification is about 50 pages,
compared to Common Lisp's 1300 page draft standard. (See the Lisp FAQ
for details on standards for Common Lisp.) Advocates of Scheme often
find it amusing that the entire Scheme standard is shorter than the
index to Guy Steele's "Common Lisp: the Language, 2nd Edition".

Scheme is often used in computer science curricula and programming
language research, due to its ability to represent many programming
abstractions with its simple primitives. Common Lisp is often used for
real world programming because of its large library of utility
functions, a standard object-oriented programming facility (CLOS), and
a sophisticated condition handling system.

See question [1-8] for information about object-oriented programming
in Scheme.

In Common Lisp, a simple program would look something like the
following:

(defun fact (n)
(if (< n 2)
1
(* n (fact (1- n)))))

In Scheme, the equivalent program would like like this:

(define fact
(lambda (n)
(if (< n 2)
1
(* n (fact (- n 1))))))

Experienced Lisp programmers might write this program as follows in order
to allow it to run in constant space:

(defun fact (n)
(labels ((tail-recursive-fact (counter accumulator)
(if (> counter n)
accumulator
(tail-recursive-fact (1+ counter)
(* counter accumulator)))))
(tail-recursive-fact 1 1)))

Whereas in Scheme the same computation could be written as follows:

(define fact
(lambda (n)
(letrec ((tail-recursive-fact
(lambda (counter accumulator)
(if (> counter n)
accumulator
(tail-recursive-fact (+ counter 1)
(* counter accumulator))))))
(tail-recursive-fact 1 1))))

or perhaps (using IEEE named LETs):

(define fact
(lambda (n)
(let loop ((counter n)
(accumulator 1))
(if (< counter 2)
accumulator
(loop (- counter 1)
(* accumulator counter))))))

Some Schemes allow one to use the syntax (define (fact n) ...) instead
of (define fact (lambda (n) ...)).

----------------------------------------------------------------
Subject: [1-3] Scheme books, introductions, documentation, periodicals,
journals, and conference proceedings.

Introductions to Scheme:

The following four books from MIT Press are listed in order of
increasing difficulty. The first is good for the complete novice,
the second for students with little or no previous exposure to programming,
and the third and fourth for more advanced students. The third and
fourth may also be used to learn a variety of powerful programming
language concepts. One of these books will suit your needs.

1. Daniel P. Friedman and M. Felleisen.
"The Little LISPer"
MIT Press (Cambridge, MA), 3rd printing, 1989. ISBN 0-262-56038-0.
Science Research Associates (Chicago), 3rd ed, 1989. 206 pages.

Good for a quick introduction. Uses Scheme instead of Common Lisp.
(The book uses a dialect of Scheme with footnotes about translating to
Scheme or Common Lisp. The footnotes won't allow a non-expert to use
Common Lisp for the advanced chapters because of the complexity.)

2. Brian Harvey and Matthew Wright
"Simply Scheme: Introducing Computer Science"
MIT Press, Cambridge, MA, 1994. 583 pages.
ISBN 0-262-08226-8. $49.95.

This book is ideal for students with little or no previous exposure to
programming. The book is designed to be used before SICP (the authors
call it a SICP "prequel"), and makes Scheme fun by sheltering the
students from potentially confusing technical details. Unlike Pascal
or C, the emphasis is on ideas, not obscure matters of syntax and
arbitrary rules of style. High schools who have shied away from using
Scheme because they found SICP to be too challenging should consider
using this book instead.

The text gradually and gently introduces students to some of the key
concepts of programming in Scheme. It starts off with functions and
function composition and continues with the notion of functions as
data (first-class functions) and programs that write programs
(higher-order functions). Since the complexity of the language is
hidden, students can get involved in some of the more interesting and
fun aspects of the language earlier than in other texts. Then the
book progresses through the more complicated concepts of lambda,
recursion, data abstraction and procedural abstraction, and concludes
with sequential techniques, but with careful attention to topics
students often find difficult. There are five chapters on recursion
alone! There's also a pitfalls section at the end of most chapters to
help students recognize and avoid common errors.

The book uses several programs as examples, including a tic-tac-toe
program, a pattern matcher, a miniature spreadsheet, and a simple
database program. Source code for the programs is available by
anonymous ftp from anarres.cs.berkeley.edu:/pub/scheme/, or for $10 on
IBM or Macintosh diskettes from the publisher.

3. Harold Abelson and Gerald Jay Sussman, with Julie Sussman.
"Structure and Interpretation of Computer Programs"
MIT Press (Cambridge, MA) and McGraw-Hill (New York), 1985.
542 pages. ISBN 0-262-01077-1, $55. The teacher's manual, which is
also available from MIT Press (ISBN 0-262-51046-4 $20), does NOT
contain solutions to the exercises, but does contain hints on
teaching with the book.

Starts off introductory, but rapidly gets into powerful
Lisp-particular constructs, such as using closures,
building interpreters, compilers and object-oriented systems. Often
referred to by its acronym, SICP, which is pronounced "Sick-Pee". This
is the classical text for teaching program design using Scheme,
and everybody should read it at least once. MIT problem sets are
available from the repositories, and materials from Gustavus
Adolphus College are available from ftp.gac.edu:/pub/SICP/.

4. George Springer and Daniel P. Friedman
"Scheme and the Art of Programming"
MIT Press and McGraw Hill, 1990, 596 pages.
ISBN 0-262-19288-8, $50.

Introduces basic concepts of programming in Scheme. Also deals with
object oriented programming, co-routining, continuations. Gives
numerous examples. Has more of an emphasis on teaching Scheme than
SICP, and can be seen as an alternative to SICP. Source code from the
chapters is available from
ftp.cs.indiana.edu:/pub/scheme-repository/doc/lit/sap/

5. Iain Ferguson, Edward Martin and Burt Kaufman.
Foreword by Daniel Friedman.
"The Schemer's Guide: Second Edition"
Schemers Inc., Ft. Lauderdale, FL, 1995. (see EdScheme entry in [2-2])
330 pages, ISBN 0-9628745-2-3, $35.95.

This book assumes no previous programming experience and is ideal
for high school or college students. The book presents
the elements of modern computer programming in an easy-to-follow and
entertaining manner. It gently introduces students to the Scheme
programming language, guiding them through such concepts as
functional programming, recursion, data structures, higher order
functions, delayed evaluation, and object-oriented programming. The
text concludes with a significant game-playing project
involving artificial intelligence. The book strikes a good balance
between theory and practice, while nurturing good programming
practices. The Schemer's Guide has a proven track record of several
years use in teaching the art of Scheme programming to high school
students and college undergraduates. A comprehensive teacher's guide
and an additional set of resource materials including worksheets,
quizzes, projects, and exams are available to instructors using this
text. (A Spanish translation will be available by August 1995.)

Older Introductions to Scheme:

1. Smith, Jerry D.
"Introduction to Scheme"
Prentice Hall (Englewood Cliffs, NJ), 1988, 324 pages.
Focuses on PC Scheme.

2. Michael Eisenberg
"Programming in Scheme"
Scientific Press (Redwood City, CA), 1988. 304 pages.

3. Two articles in BYTE Magazine, February 1988, by Abelson and
Sussman, and Clinger.

Online Introductions to Scheme:

1. The Ken Dickey article, "The Scheme Programming Language", in
COMPUTER LANGUAGES magazine, June 1992, is available from the
Scheme Repository at
ftp.cs.indiana.edu:/pub/scheme-repository/doc/pubs/intro.txt
The Revised^4 Report on the Algorithmic Language Scheme is also
available from the Scheme Repository.

2. The Info files from the MIT Scheme implementation.
ftp.cs.indiana.edu:/pub/scheme-repository/imp/MIT-Scheme-7.3/doc

3. "Introductory Scheme" by Joseph W. Lavinus and James D. Arthur,
<lav...@virginia.edu>. Available from the Lisp Utilities
Repository as ftp.cs.cmu.edu:/user/ai/lang/scheme/doc/intro/
as scmintro.tgz.

Scheme and Artificial Intelligence:

1. Wolfgang Kreutzer and Bruce McKenzie
"Programming for Artificial Intelligence:
Methods, Tools and Applications"
Addison-Wesley (Reading, MA), 1990. 682 pages.
ISBN 0-201-41621-2.
Discusses Scheme, Prolog, and Smalltalk, gives an overview of
the history and philosophy of AI, surveys three major
programming paradigms (procedural, declarative, and
object-oriented), and metaphors to AI programming.
Source code from the chapters is available from
ftp.cs.indiana.edu:/pub/scheme-repository/lit/
as aibook.tar.Z. Some of the programs will only run under MacScheme.

Scheme-based Computer Science Texts:

1. Vincent Manis and James Little
"The Schematics of Computation"
Prentice-Hall, Inc., 1995. 848 pages
ISBN 0-13-834284-9 (North America), $41
ISBN 0-13-433772-7 (International).

For a copy of the publication announcement, see
ftp.cs.cmu.edu:/user/ai/pubs/books/announce/manis95

General Scheme reference books include:

1. K. Dybvig
"The Scheme programming language"
Prentice Hall, 1987.
Good reference for Scheme.

Scheme-related periodicals include:

1. LISP Pointers.
Published by ACM SIGPLAN six times a year. Volume 1, Number 1
was April-May 1987.
Subscriptions: ACM Members $12; ACM Student Members $7; Non-ACM
members $25. Mail checks payable to the ACM to ACM Inc., PO Box
12115, Church Street Station, New York, NY 10249.

2. LISP and Symbolic Computation, Kluwer Academic Press. Volume 1
was published in 1989. (j...@lucid.com is the editor). ISSN 0892-4635.
Subscriptions: Institutions $169; Individuals $80. Add $8 for
air mail. Kluwer Academic Publishers, PO Box 322, 3300 AH Dordrecht,
The Netherlands, or Kluwer Academic Publishers, PO Box 358, Accord
Station, Hingham, MA 02018-0358.

3. Proceedings of the biannual ACM Lisp and Functional Programming
Conference. (First one was in 1980.)

4. Proceedings of the annual Lisp Users and Vendors Conference.

See also the Scheme Bibliography from the Scheme Repository
(ftp.cs.indiana.edu:/pub/scheme-repository/) for additional readings.
A large number of technical reports on Scheme are now available in the
text section (ftp.cs.indiana.edu:/pub/scheme-repository/txt/).

----------------------------------------------------------------
Subject: [1-4] Where can I learn about implementing Scheme interpreters
and compilers?

There is no single book that is really comprehensive, so you will have
to combine reading the sources to the various free implementations
(e.g., Gambit [Feeley] and S48 [Rees]) with bits and pieces of tech
reports and various books.

Books about Scheme implementation include:

1. John Allen
"Anatomy of Lisp"
McGraw-Hill, 1978. 446 pages. ISBN 0-07-001115-X

2. Samuel Kamin
"Programming Languages, An Interpreter-Based Approach"
Addison-Wesley, Reading, Mass., 1990. ISBN 0-201-06824-9
Includes sources to several interpreters for Lisp-like
languages, and a pointer to sources via anonymous ftp.

3. Sharam Hekmatpour
"Lisp: A Portable Implementation"
Prentice Hall, 1985. ISBN 0-13-537490-X.
Describes a portable implementation of a small dynamic
Lisp interpreter (including C source code).

4. Peter Henderson
"Functional Programming: Application and Implementation"
Prentice-Hall (Englewood Cliffs, NJ), 1980. 355 pages.

5. Peter M. Kogge
"The Architecture of Symbolic Computers"
McGraw-Hill, 1991. ISBN 0-07-035596-7.
Includes sections on memory management, the SECD and
Warren Abstract Machines, and overviews of the various
Lisp Machine architectures.

6. Daniel P. Friedman, Mitchell Wand, and Christopher T. Haynes
"Essentials of Programming Languages"
MIT Press, 1992, 536 pages. ISBN 0-262-06145-7, $55.
Teaches fundamental concepts of programming language
design by using small interpreters as examples. Covers
most of the features of Scheme. Includes a discussion
of parameter passing techniques, object oriented languages,
and techniques for transforming interpreters to allow
their implementation in terms of any low-level language.
Also discusses scanners, parsers, and the derivation of
a compiler and virtual machine from an interpreter.
Source files available by anonymous ftp from
ftp.cs.indiana.edu:/pub/eopl/ (129.79.254.191) or from the
Scheme Repository in
ftp.cs.indiana.edu:/pub/scheme-repository/doc/lit/eopl

7. Peter Lee, editor, "Topics in Advanced Language Implementation",
The MIT Press, Cambridge, Mass., 1991.
Articles relevant to the implementation of functional
programming languages.

8. Also see the proceedings of the biannual ACM Lisp and Functional
Programming conferences, the implementation notes for CMU Common Lisp,
Peter Norvig's book ("Paradigms of AI Programming: Case Studies
in Common Lisp", Morgan Kaufmann, 1992. 946 pages. ISBN
1-55860-191-0), and SICP (Abelson & Sussman).

9. Christian Queinnec
"Les Langages Lisp"
InterEditions (in French), 1994. 500 pages.
ISBN 2-7296-0549-5, 61-2448-1. (?)

The book covers Lisp, Scheme and other related dialects,
their interpretation, semantics and compilation.

All of the programs described in the book are available by
anonymous ftp from
ftp.inria.fr:/INRIA/Projects/icsla/Books/LiSP94Sep05.tar.gz
For more information, see the book's URL
file://ftp.inria.fr/INRIA/Projects/icsla/WWW/LiSP.html
or contact the author at Christian...@inria.fr

Technical reports and journal articles about Scheme implementation include:

Mitchell Wand and Daniel P. Friedman, "Compiling Lambda Expressions
Using Continuations and Factorizations", Journal of Computer Languages
3(1978), 241-263.

Guy Lewis Steele Jr., "Rabbit: A Compiler for Scheme", MIT AI Memo
474, Massachusetts Institute of Technology, Cambridge, MA, May 1978.

Guy Lewis Steele Jr., "Compiler Optimization Based on Viewing LAMBDA
as RENAME + GOTO", in "Artificial Intelligence: An MIT Perspective",
Patrick Henry Winston and Richard Henry Brown (eds.), MIT Press,
Cambridge, MA, 1980.

Jonathan A. Rees and Norman I. Adams, "T: A Dialect of Lisp or,
LAMBDA: The Ultimate Software Tool", Conference Record of the 1982 ACM
Symposium on Lisp and Functional Programming, 1982, 114-122.

R. Kent Dybvig, "C-Scheme", Computer Science Department Technical
Report #149 (MS Thesis), Indiana University, Bloomington, IA, 1983.

William Clinger, "The Scheme 311 compiler: An Exercise in Denotational
Semantics", Conference Record of the 1984 ACM Symposium on Lisp and
Functional Programming, 1984, 356-364.

Guillermo J. Rozas, "Liar, an Algol-like Compiler for Scheme", S.B.
Thesis, Department of Electrical Engineering and Computer Science,
Massachusetts Institute of Technology, January 1984.

David H. Bartley and John C. Jensen, "The Implementation of PC
Scheme", Proceedings of the 1986 ACM Conference on Lisp and Functional
Programming, 1986, 86-93.

David Kranz, Richard Kelsey, Jonathan A. Rees, Paul Hudak, James
Philbin and Norman I. Adams, "Orbit: An Optimizing Compiler for
Scheme", Proceedings of the SIGPLAN Notices '86 Symposium on Compiler
Construction, June 1986, 219-233. Published as SIGPLAN Notices 21(7),
July 1986.

Marc Feeley, "Deux Approches a' L'implantation du Language Scheme",
M.Sc. Thesis, De'partement d'Informatique et de Recherche
Ope'rationelle, University of Montreal, May 1986.

R. Kent Dybvig, "Three Implementation Models for Scheme", Department
of Computer Science Technical Report #87-011 (Ph.D. Dissertation),
University of North Carolina at Chapel Hill, Chapel Hill, North
Carolina, April 1987.

William D. Clinger, Anne H. Hartheimer and Eric M. Ost,
"Implementation Strategies for Continuations", Conference Record of
the 1988 ACM Conference on Lisp and Functional Programming, August
1988, 124-131.

David Kranz, "Orbit: An Optimizing Compiler for Scheme", Computer
Science Technical report #632 (Ph.D. Dissertation), Yale University,
1988.

Joel F. Bartlett, "SCHEME->C a Portable Scheme-to-C Compiler",
Research Report 89/1, Dec. Western Research Laboratory, Palo Alto, CA,
January 1989.

Marc Feeley and James S. Miller, "A Parallel Virtual Machine for
Efficient Scheme Compilation", Proceedings of the 1990 ACM Conference
on Lisp and Functional Programming, Nice, France, June 1990.

Chris Hanson, "Efficient Stack Allocation for Tail-Recursive
Languages", Proceedings of the 1990 ACM Conference on Lisp and
Functional Programming, Nice, France, June 1990.

Robert Hieb, R. Kent Dybvig and Carl Bruggeman, "Representing Control
in the Presence of First-Class Continuations", Proceedings of the
SIGPLAN Notices '90 Conference on Programming Language Design and
Implementation, White Plains, New York, June 1990, 66-77.

Guillermo Rozas, "Taming the Y Operator", Proceedings of the 1992 ACM
Conference on Lisp and Functional Programming, San Francisco, CA,
June 1992, 226-234.

Dan Teodosiu, "HARE: An Optimizing Portable Compiler for Scheme", ACM
Sigplan Notices 26(1), January 1991.

----------------------------------------------------------------
Subject: [1-7] Standards for Scheme -- What are R4RS and IEEE P1178?

R4RS is the Revised^4 Report on the Algorithmic Language Scheme,
edited by W. Clinger and J. Rees. It appeared in ACM Lisp Pointers IV,
July-September 1991, and also as MIT AI Memo 848b. It serves as a kind
of standard for the language. It can be obtained by anonymous ftp at
the two Scheme Repositories, swiss-ftp.ai.mit.edu and ftp.cs.indiana.edu.
A HTML version is available as
ftp://swiss-ftp.ai.mit.edu/pub/scm/HTML/r4rs_toc.html
or
http://www.maths.tcd.ie/scrg/scheme/index.html

IEEE P1178 is IEEE Standard 1178-1990, "IEEE Standard for the Scheme
Programming Language", published by IEEE in 1991. ISBN 1-55937-125-0.
It is now also an ANSI standard. It may be ordered from IEEE by
calling 1-800-678-IEEE or 908-981-1393 or writing IEEE Service
Center, 445 Hoes Lane, P.O. Box 1331, Piscataway, NJ 08855-1331,
and using order number SH14209 ($28 for IEEE members, $40 others).

----------------------------------------------------------------
Subject: [1-8] How do I do object-oriented programming in Scheme?

Some Scheme implementations (for example, MacScheme, Feel, Oaklisp, XScheme,
and PC-Scheme) include built-in object-oriented extensions.

BOS (Bryan's Object System) is a very small object system for Scheme.
It is based around generic functions and multiple inheritance. BOS
provides more or less the same features as Meroon and the Tiny CLOS
base language. Even though it has not been optimised, it should be
quite a bit faster than those because it does not include a MOP.
BOS has been tested under Scheme 48 and SCM, and should run under any
fairly modern Scheme implementation (especially any which runs SLIB)
with little or no change. It is available by anonymous ftp from
ftp.maths.tcd.ie:/pub/bosullvn/misc/bos.tar.gz
and the CMU AI Repository in
ftp.cs.cmu.edu:/user/ai/lang/scheme/oop/bos/
For more information, write to Bryan O'Sullivan <bosu...@maths.tcd.ie>.

MEROON is a package written in Scheme to provide the basic facilities
of an object-oriented programming style through three macros:
define-class, define-generic, and define-method. MEROON offers simple
inheritance, reflective metaclasses and simple dispatching generic
functions with support for multimethods. MEROON also offers indexed
fields subsuming Scheme vectors without inheritance restrictions.
Meroon runs in Scheme->C, PC-Scheme, Chez Scheme, Elk, Bigloo, SCM
with SLIB, and MacGambit. MEROON sources and documentation may be
found in the Scheme Repository as
ftp.cs.indiana.edu:/pub/scheme-repository/new/meroon.*.tar.Z
and also from
ftp.inria.fr:/pub/INRIA/icsla/Programs/MeroonV3*.tar.gz [128.93.1.26]
The file meroonet*.tar.gz is a toy version of meroon. For more
information, contact Christian Queinnec <quei...@polytechnnique.fr>
or <Christian...@inria.fr>.

SCOOPS (Scheme Object Oriented Programming System) is an object system
for Scheme written by Amitabh Srivastava/Texas Instruments with
re-writes by Steve Sherin <she...@linc.cis.upenn.edu>. [Email to this
address bounced 7/7/93.] This package needs first-class environments.
It is available from the Scheme Repository as
/pub/scheme-repository/scm/scoops.sha.

Tiny CLOS is a Scheme implementation of a `kernelized' CLOS, with a
metaobject protocol. The implementation is even simpler than the
simple CLOS found in `The Art of the Metaobject Protocol,' weighing in
at around 850 lines of code, including (some) comments and
documentation. Tiny CLOS is available by anonymous ftp from
parcftp.xerox.com:/pub/mops/. Tiny CLOS runs in MIT Scheme 11.74 and
should run with only minor modifications in other Schemes as well. If
you want to be added to the mo...@parc.xerox.com mailing list
(technical questions and discussion only), send mail to Gregor Kiczales
<gre...@parc.xerox.com>.

YASOS (Yet Another Scheme Object System) is fairly functional in style
and uses delegation. The implementation includes multiple inheritance
and "send to super" and is much smaller than class-based OO systems.
See Ken Dickey, "Scheming with Objects", AI Expert 7(10):24-33,
October 1992. A copy of the article and YASOS code is available from
the Scheme Repository in pub/scheme-repository/txt/swob.txt. YASOS is also
included as part of SLIB. For further information, contact Ken Dickey
<ke...@newton.apple.com>.

----------------------------------------------------------------
Subject: [1-9] Repositories of Scheme Software

There are several repositories of publicly redistributable and
public domain Scheme code.

CMU AI Repository, Scheme Section:

The Scheme Section of the CMU Artificial Intelligence Repository
is accessible by anonymous ftp to
ftp.cs.cmu.edu:/user/ai/lang/scheme/ [128.2.206.173]
through the AFS directory
/afs/cs.cmu.edu/project/ai-repository/ai/lang/scheme/
or by WWW from the URL
http://www.cs.cmu.edu/Web/Groups/AI/html/repository.html
and includes more than 200 megabytes of sources and other materials
of interest to Scheme programmers, including all freely
distributable implementations and many programs. Unlike the Scheme
Repository at Indiana University, the entire contents of the CMU AI
Repository has been keyword indexed to provide convenient browsing
of the contents.

The repository has standardized on using 'tar' for producing
archives of files and 'gzip' for compression.

To search the keyword index by mail, send a message to:
ai+q...@cs.cmu.edu
with one or more lines containing calls to the keys command, such as:
keys scheme awk
in the message body. Keywords may be regular expressions and are
compared with the index in a case-insensitive conjunctive fashion.
You'll get a response by return mail. Do not include anything else in
the Subject line of the message or in the message body. For help on
the query mail server, include:
help
instead.

A Mosaic interface to the keyword searching program is in the
works. We also plan to make the source code (including indexes) to
this program available, as soon as it is stable.

Most of the Scheme Section of the AI Repository appears on Prime Time
Freeware for AI, Issue 1-1, a mixed-media book/CD-ROM publication. It
includes two ISO-9660 CD-ROMs bound into a 224 page book and sells
(list) for US$60 plus applicable sales tax and shipping and handling
charges. Payable through Visa, Mastercard, postal money orders in US
funds, and checks in US funds drawn on a US bank. For more
information write to Prime Time Freeware, 370 Altair Way, Suite 150,
Sunnyvale, CA 94086 USA, call 408-433-9662, 408-433-0727 (fax),
or send email to p...@cfcl.com.

Contributions of software and other materials are always welcome but
must be accompanied by an unambiguous copyright statement that grants
permission for free use, copying, and distribution -- either a
declaration by the author that the materials are in the public domain,
that the materials are subject to the GNU General Public License (cite
version), or that the materials are subject to copyright, but the
copyright holder grants permission for free use, copying, and
distribution. (We will tell you if the copying permissions are too
restrictive for us to include the materials in the repository.)
Inclusion of materials in the repository does not modify their
copyright status in any way. Materials may be placed in:
ftp.cs.cmu.edu:/user/ai/new/
When you put anything in this directory, please send mail to
ai+co...@cs.cmu.edu
giving us permission to distribute the files, and state whether
this permission is just for the AI Repository, or also includes
publication on the CD-ROM version (Prime Time Freeware for AI).
We would also appreciate if you would include a 0.doc file for your
package; see /user/ai/new/package.doc for a template. (If you don't
have the time to write your own, we can write it for you based on
the information in your package.)

The Scheme Section of the AI Repository is maintained by Mark Kantrowitz
<AI.Rep...@cs.cmu.edu>.

Scheme Repository at Indiana University:

The Scheme Repository at Indiana University contains a Scheme
bibliography, copies of the R4RS report and other papers, sample
Scheme code for a variety of purposes, several utilities, and some
implementations. The Scheme code includes code for calendar
calculations, Earley parser, FORMAT for Scheme, a scheme version of
the Gabriel benchmarks, Marc Feeley's minimal object support for
Scheme, a Scheme pretty-printer, a Prolog interpreter written in
Scheme, a random number generator in Scheme, an implementation of
SCOOPS, code from Abelson and Sussman's SICP book, Aubrey Jaffer's
IEEE/R4RS compliance test, an implementation of matrices, a Scheme
implementation of the Common Lisp FORMAT function, a Scheme front end
to Adobe Illustrator PostScript, and a LALR(1) parser (ZEBU). The
repository was established by Ozan S. Yigit and is currently
maintained by David Eby and John Zuckerman. Send administrative
requests to
scheme-repos...@cs.indiana.edu
The repository is accessible by anonymous ftp at
ftp.cs.indiana.edu:/pub/scheme-repository/ [129.79.254.191]
or by WWW to
http://www.cs.indiana.edu/scheme-repository/home.html
The repository is mirrored in INRIA, courtesy of Christian Queinnec
[Ecole Polytechnique and INRIA-Rocquencourt], ftp.inria.fr:/lang/Scheme/
and also faui80.informatik.uni-erlangen.de:/pub/scheme/yorku

Other Scheme Collections:

Scheme Implementations may also be found at swiss-ftp.ai.mit.edu:/archive/
The R4RS report is available in
swiss-ftp.ai.mit.edu:/archive/scheme-reports/
or as MIT AI Memo 848b (email public...@ai.mit.edu for more information).
The swiss-ftp archive includes SCOOPS, CL2Scheme, extend-syntax,
btree, Gabriel benchmarks, FORMAT for Scheme, etc.

The GI (German Computer Science Society) Scheme Archive contains a
variety of scheme programs, utilities, code from theses, and other
materials. It also mirrors the Scheme Repository. It is
accessible by anonymous ftp to faui80.informatik.uni-erlangen.de
(login as 'ftp', giving your email address as the password).
pub/scheme/gi # GI Scheme Archive
pub/scheme/yorku # Internet Scheme Repository
Direct questions to sch...@faui80.informatik.uni-erlangen.de.
The GI Scheme Archive is supported by the German Computer Society Special
Interest Group on AI programming and sponsored by the Bavarian AI Center
FORWISS -- Research Institute for Knowledge Based Systems.

----------------------------------------------------------------
Subject: [1-10] Publicly Redistributable Scheme Software

SLIB (Standard Scheme Library) is a portable scheme library that
provides compatibility and utility functions for many of the
standard scheme implementations, including Chez, ELK 2.1, GAMBIT,
MITScheme, scheme->C, Scheme48, T3.1, VSCM and Scm4e. It is available by
anonymous ftp from
swiss-ftp.ai.mit.edu:/archive/scm/slib2a1.tar.gz
prep.ai.mit.edu:/pub/gnu/jacal/slib2a1.tar.gz
ftp.cs.indiana.edu:/pub/scheme-repository/new/slib2a1.tar.gz
Now includes a FAQ file.

TEST.SCM is an IEEE and R4RS conformance test suite. It is available
from
swiss-ftp.ai.mit.edu:/archive/scm/test.scm
prep.ai.mit.edu:/pub/gnu/jacal/test.scm
ftp.cs.indiana.edu:/pub/scheme-repository/new/test.scm

PSD (Portable Scheme Debugger) is available by anonymous ftp
from Tampere University of Technology, Finland,
ftp.cs.tut.fi:/pub/src/languages/schemes/psd-1.1.tar.Z
With PSD, you can run a Scheme program in an Emacs buffer, set
breakpoints, single step evaluation and access and modify the
program's variables. It works by instrumenting the original source
code, so it should run with any R4RS compliant Scheme. It has been
tested with SCM and Elk 1.5, but should work with other Schemes with a
minimal amount of porting, if at all. Includes documentation and
user's manual. Written by Pertti Kellom\"aki, p...@cs.tut.fi
The Lisp Pointers article describing PSD (Lisp Pointers VI(1):15-23,
January-March 1993) is available as
http://www.cs.tut.fi/staff/pk/scheme/psd/article/article.html

SCLINT is a lint-like program for Scheme. It checks for consistency of
indentation, syntax of special forms, and the number of arguments to
primitive and most user-defined procedures. This is not a full
implementation, but rather a quick hack. It is used in teaching
programming at the Tampere University of Technology. It is available
by anonymous ftp from
ftp.cs.tut.fi:/pub/src/languages/schemes/sclint-0.9.tar.Z.
For further information, write to Pertti Kellom\"aki <p...@cs.tut.fi>.

A bibliography of work in functional programming can be obtained by
anonymous ftp from tamdhu.dcs.st-andrews.ac.uk:/pub/staple/pubs.txt
(138.251.192.40). It uses a refer-like format with %T for title, %A
for authors %I for a unique index entry %S for source (possibly a
reference to another index) %K for keywords and %C for comments.
Compiled by Tony Davie, <aj...@honey.st-and.ac.uk>. [Email bounced, 7/7/93.]

Scheme Utilities -- brokaw.lcs.mit.edu:/pub/scmutils.tar 18.30.0.33
[This collection seems to no longer be located on brokaw -- does
anybody know the current location?]

A collection of Scheme implementations of data structures and
algorithms is available by anonymous ftp from
ftp.cs.tut.fi:/pub/src/languages/schemes/
as the file scheme-algorithms.tar. For more information, contact
Pertti Kellom\"aki <p...@cs.tut.fi>.

6.001. The User's Manual, example code, and problem sets from MIT's
course "Structure and Interpretation of Computer Programs" are
available by anonymous ftp from swiss-ftp.ai.mit.edu:/archive/6.001/
[18.23.0.16].

Steele's Constraint System. Chris Hanson's implementation of Steele's
constraint system is available for anonymous ftp from
swiss-ftp.ai.mit.edu:/archive/cph/constraint.tar [18.23.0.16]
ftp.cs.indiana.edu:/pub/scheme-repository/new/constraint.tar.Z
A compressed version is also stored there. The software is source code
for MIT Scheme. It should run in release 7.1.3. Most of the MIT Scheme
dependencies could be eliminated, but it also uses the following
procedures which aren't in standard Scheme: error, bkpt, macros,
dynamic binding, and string output ports. The code corresponds pretty
closely to Guy Steele's PhD thesis implementation, which you can
obtain in printed form from the MIT AI Lab publications office as
AI-TR-595 for $15.00 (email public...@ai.mit.edu for more
information). For more information, send email to Chris Hanson
<c...@martigny.ai.mit.edu>.

JACAL is a symbolic mathematics system for the simplification and
manipulation of equations and single and multiple valued algebraic
expressions constructed of numbers, variables, radicals, and algebraic
functions, differential, and holonomic functions. In addition, vectors
and matrices of the above objects are included. JACAL is written in
Scheme and requires SLIB. JACAL source is available via anonymous FTP
from
swiss-ftp.ai.mit.edu:/archive/scm/jacal1a4.tar.Z,
prep.ai.mit.edu:/pub/gnu/jacal/jacal1a4.tar.Z, and
ftp.cs.indiana.edu:/pub/scheme-repository/new/jacal1a4.tar.Z
Contact jaf...@altdorf.ai.mit.edu for more information.

Zebu 0.9 is an LALR(1) parser generator for Scheme written by
William M. Wells III. It lives in the Scheme Repository
ftp.cs.indiana.edu:/pub/scheme-repository/scm/
and works with PC-Scheme from TI and MIT C-Scheme 6.2 (but not with
anything after 7.0).

Thomas is a compiler for the Dylan programming language. The Thomas
system is written in Scheme and runs under MIT's CScheme, DEC's
Scheme->C, and Marc Feeley's Gambit. It can run on a wide range of
machines including the Macintosh, PC compatibles, Vax, MIPS, Alpha,
and 680x0. Thomas generates IEEE compatible Scheme code. Thomas is
available to the public by anonymous ftp at
crl.dec.com:/pub/DEC/Thomas
gatekeeper.pa.dec.com:/pub/DEC/Thomas
swiss-ftp.ai.mit.edu:/archive/Thomas
For more information on Thomas and Dylan, see part 4 of the Lisp FAQ.

MATCH is a pattern matching macro package for Scheme. Pattern
matching allows complicated control decisions based on data structure
to be expressed in a concise manner. This document describes several
pattern matching macros for Scheme, and an associated mechanism for
defining new forms of structured data. This macro package works with
any Scheme that supports defmacro (which is obtainable by loading
SLIB), such as Chez Scheme (release 4 or greater). MATCH is available
by anonymous ftp from titan.cs.rice.edu:/public/wright/match.tar.Z
[128.42.1.30] and includes the macro source code and documentation. A
copy should be available from the Scheme Repository shortly. For
further information, write to Andrew Wright, <wri...@cs.rice.edu>.

Soft Scheme provides the benefits of static typing for dynamically
typed Scheme. Like a static type checker, a soft type checker infers
types for variables and expressions. But rather than reject programs
containing untypable fragments, a soft type checker inserts explicit
run-time checks to transform untypable programs to typable form.
These run-time checks indicate potential program errors, enabling
programmers to detect errors prior to program execution. Soft type
checking minimizes the number of run-time checks in the compiled code,
enabling dynamically typed languages to attain the efficiency of
statically typed languages like ML. Soft Scheme is available by
anonymous ftp from
titan.cs.rice.edu:public/wright/softscheme.tar.Z [128.42.1.30]
For more information, write to Andrew Wright <wri...@cs.rice.edu>.

ChezSybase is a Chez Scheme interface to the Sybase database.
It uses the Chez Scheme foreign function interface to provide a
high-level Scheme interface to the Sybase db-lib (the API to the
Sybase database). Most of the db-lib calls and datatypes are
supported, with the possible exception of spotty support for text and
image data, and there is no analog to the datetime datatype. It is
available by anonymous ftp from
ftp.cs.cmu.edu:/user/ai/lang/scheme/code/io/chez_syb/
For more information, write to Karl O. Pinc <k...@acm.org>.

----------------------------------------------------------------
Subject: [1-11] Formatting code in LaTeX

SLaTeX is a R4RS-compliant Scheme program that allows you to write
program code "as is" in your LaTeX or TeX source. It is particularly
geared to the programming languages Scheme and Common Lisp, and has
been tested in Chez Scheme, Common Lisp, MIT C Scheme, Elk, Scheme->C,
SCM and UMB Scheme on Unix; and MIT C Scheme and SCM on MSDOS. The
formatting of the code includes assigning appropriate fonts to the
various tokens in the code (keywords, variables, constants, data), at
the same time retaining the proper indentation when going to the
non-monospace (non-typewriter) provided by TeX. SLaTeX comes with two
databases that recognize the standard keywords/variables/constants of
Scheme and Common Lisp respectively. These can be modified by the
user using easy TeX commands. In addition, the user can inform SLaTeX
to typeset arbitrary identifiers as specially suited TeX expressions
(i.e., beyond just fonting them). The code-typesetting program SLaTeX
is available by anonymous ftp from
cs.rice.edu:/public/dorai/slatex23.tar.gz
Send bug reports to do...@cs.rice.edu.

SchemeWEB provides simple support for literate programming in Lisp.
SchemeWEB version 2.0 is a Unix filter that allows you to generate
both Lisp and LaTeX code from one source file. The generated LaTeX
code formats Lisp programs in typewriter font obeying the spacing in
the source file. Comments can include arbitrary LaTeX commands.
SchemeWEB was originally developed for the Scheme dialect of Lisp, but
it can easily be used with most other dialects. Version 2.0 is
available in the Scheme Repository as
ftp.cs.indiana.edu:/pub/scheme-repository/new/schemeweb.sh
or in the Comprehensive TeX Archive Network (CTAN) in the directory
ftp.shsu.edu:/tex-archive/web/schemeweb

The Literate Programming FAQ lists a number of alternatives, both
language-independent and Scheme-specific. The Literate Programming FAQ
is posted once a quarter to the comp.programming.literate newsgroup
and is available by anonymous ftp from rtfm.mit.edu. A copy may also be
requested by sending an email message to file...@shsu.edu
sendme litprog.faq
in the body of the message.

----------------------------------------------------------------
Subject: [1-12] Where can I get an implementation of Prolog in Scheme?

Prolog in Scheme is a collection of macros that expand syntax for
clauses, elations, and so on. It is written in Scheme and has support
for delayed goals and interval arithmetic. It is known to run in Chez
Scheme and in Elk, and is intended to be portable to other Scheme
implementations. It relies on continuations, and so is not easily
ported to Common Lisp. Available from the University of Calgary by
anonymous ftp from
ftp.cpsc.ucalgary.ca:/pub/projects/prolog1.2/prolog12.tar.Z
Questions and comments may be addressed to Alan Dewar
<de...@cpsc.ucalgary.ca> or John Cleary <jcl...@waikato.ac.nz>.

Schelog is an embedding of Prolog in Scheme. It represents Prolog
goals as procedures in Scheme, and includes macros to simulate a
Prolog-style syntax for clauses, relations and queries. The embedding
permits the user to combine Prolog and Scheme code freely, in the same
s-expression, if desired. Documentation and examples are included.
Schelog should run in any R4RS Scheme, has been tested in SCM and Chez
Scheme, and will run in any Scheme implementation that supports SLIB (see
entry in [1-10] above). Schelog (version 2) is available by anonymous
ftp from titan.cs.rice.edu:/public/dorai/schelog2.tar.Z. Its use of
higher-order continuations is probably a major obstacle to porting it
to Common Lisp. For more information, please contact the author Dorai
Sitaram <do...@cs.rice.edu>.

----------------------------------------------------------------
Subject: [1-13] What does SICP, SCOOPS, R4RS, CAR, CDR, ... mean?

Glossary of acronyms:
CAR Originally meant "Contents of Address portion of Register",
which is what CAR actually did on the IBM 704.
CDR Originally meant "Contents of Decrement portion of
Register", which is what CDR actually did
on the IBM 704. Pronounced "Cudder".
ANSI American National Standards Institute
SICP Abelson and Sussman's book "Structure and
Interpretation of Computer Programs".
EOPL Essentials of Programming Languages
SCOOPS An experimental object-oriented programming
language for Scheme.
R3RS Revised^3 Report on the Algorithmic Language Scheme.
R4RS Revised^4 Report on the Algorithmic Language Scheme.

----------------------------------------------------------------
Subject: [1-14] Why is there no EVAL in Scheme?

The answer to this question is based on information provided by
Guillermo J. Rozas and Aubrey Jaffer.

There are three major positions in the Scheme community regarding EVAL:

1. No EVAL: EVAL is antithetical to a Pascal-like (compiler based,
externally statically linked) implementation for Scheme, such as
some people have or wish to see.

2. Single Argument: There is a single distinguished top-level
environment, and EVAL always evaluates its argument there.
(This is the approach taken in Common Lisp, where EVAL evaluates
its argument in the current dynamic environment and in a null
lexical environment.)

3. Two Arguments: There are multiple environments in which
the user might want to evaluate expressions, so EVAL should take
two arguments, the second being an environment. In particular,
in some systems with first-class environments, there is no
a-priori single distinguished top-level environment, and
defaulting the environment does not fit those dialects well.

Not every dialect of Scheme has EVAL. Most do, but some with different
names and arguments. Jaffer's SLIB package uses LOAD as defined in
R4RS to define EVAL for those implementations that don't support EVAL
(e.g., by writing the code out to a file and then loading it).
Rozas's compromise proposal for EVAL was accepted for R5RS, but it is
unclear whether there will ever be a R5RS.

----------------------------------------------------------------
Subject: [1-15] World-Wide Web (WWW) Resources

The World Wide Web (WWW) is a hypermedia document that spans the
Internet. It uses the http (HyperText Transfer Protocol) for the
light-weight exchange of files over the Internet. NCSA Mosaic is a
World Wide Web browser developed at the National Center for
Supercomputing Applications (NCSA).

Mosaic's popularity derives, in part, from its ability to communicate
using more traditional Internet protocols like FTP, Gopher, WAIS, and
NNTP, in addition to http. Mosaic can display text, hypertext links,
and inlined graphics directly. When Mosaic encounters a file type it
can't handle internally, such as Postscript documents, mpeg movies,
sound files, and JPEG images, it uses an external viewer (or player)
like Ghostscript to handle the file. Mosaic also includes facilities
for exploring the Internet. In other words, Mosaic is an multimedia
interface to the Internet.

The hypertext documents viewed with Mosaic are written in HTML
(HyperText Markup Language), which is a subset of SGML (Standard
Generalized Markup Language). All that is needed is just a few more
improvements, such as the ability to format tables and mathematics,
and a WYSIWYG editor, for HTML to greatly facilitate electronic
journals and other publications.

NCSA Mosaic for the X Window System is available by anonymous ftp from
ftp.ncsa.uiuc.edu:/Mosaic/
as source code and binaries for Sun, SGI, IBM RS/6000, DEC Alpha OSF/1, DEC
Ultrix, and HP-UX. Questions about NCSA Mosaic should be directed to
mosa...@ncsa.uiuc.edu (X-Windows version), mosai...@ncsa.uiuc.edu
(Macintosh), and mosai...@ncsa.uiuc.edu (Microsoft Windows).

A simple HTML version of the Scheme FAQ (this FAQ) is available as
http://www.cs.cmu.edu/Web/Groups/AI/html/faqs/lang/scheme/top.html

The Scheme home page at MIT is
http://www-swiss.ai.mit.edu/scheme-home.html
It includes a nifty little form that lets you execute small examples
of Scheme code.

The Scheme Underground web page is
http://www.ai.mit.edu/projects/su/su.html

----------------------------------------------------------------
Subject: [1-16] Why is Scheme called 'Scheme'?

According to Steele and Gabriel's "The Evolution of Lisp" paper,
Scheme was originally called Schemer, in the tradition of the AI
languages Planner and Conniver. But the ITS operating system had a
6-character limitation of file names, so the names were shortened to
PLNR, CNVR, and SCHEME. Eventually the truncated name Scheme stuck.

----------------------------------------------------------------
;;; *EOF*


Mark Kantrowitz

unread,
Jul 13, 1997, 3:00:00 AM7/13/97
to

Archive-name: scheme-faq/part2
Last-Modified: Wed Apr 30 14:12:45 1997 by Mark Kantrowitz
Version: 1.32Size: 50193 bytes, 893 lines

;;; ****************************************************************
;;; Answers to Frequently Asked Questions about Scheme *************
;;; ****************************************************************
;;; Written by Mark Kantrowitz and Barry Margolin

;;; scheme_2.faq

This post contains part 2 of the Scheme FAQ.

If you think of questions that are appropriate for this FAQ, or would
like to improve an answer, please send email to us at ai+li...@cs.cmu.edu.

Topics Covered (Part 2):


[2-1] Free Scheme implementations.
[2-2] Commercial Scheme implementations.
[2-3] What Scheme-related discussion groups and mailing lists exist?

Search for \[#\] to get to question number # quickly.

----------------------------------------------------------------
Subject: [2-1] Free Scheme implementations.

Repositories of Scheme source code are described in the answer to
question [1-9].

Remember, when ftping compressed or compacted files (.Z, .z, .arc, .fit,
etc.) to use binary mode for retrieving the files.

Files that end with a .z suffix were compressed with the patent-free
gzip (no relation to zip). Source for gzip is available from:
prep.ai.mit.edu:/pub/gnu/
as the files gzip-1.2.4.shar, gzip-1.2.4.tar,or gzip-1.2.4.msdos.exe.

Repositories of Scheme implementations:

Many free Scheme implementations are available from swiss-ftp.ai.mit.edu
[18.43.0.246]. See also the Scheme Repository described below.

The Scheme Repository contains a Scheme bibliography, copies of the
R4RS report, sample Scheme code for a variety of purposes, several
utilities, and most free implementations. (Implementations of Scheme
available from the repository include elk, gambit, scm, fools, rabbit,
s48, scheme84, scheme88, pseudo, xscheme, umb-scheme, siod, vscm, and
pixiescheme.) The repository was established by Ozan S. Yigit and


is currently maintained by David Eby and John Zuckerman

<scheme-repos...@cs.indiana.edu>. The repository is


accessible by anonymous ftp at
ftp.cs.indiana.edu:/pub/scheme-repository/ [129.79.254.191]

The repository is mirrored in INRIA, courtesy of Christian Queinnec

[Ecole Polytechnique and INRIA-Rocquencourt], ftp.inria.fr:/lang/Scheme.
(See also [1-9].)

Scheme implementations:

BIGLOO is a Scheme interpreter and compiler. It conforms to the
IEEE-Scheme standard (IEEE P1178) with some extensions, such as
regular expression parsing (RGC), a lexical analyzer generator, a full
foreign function interface, and a pattern matching compiler. Bigloo
can also compile modules written in Caml (an ML dialect), letting you
mix Scheme, ML, and C. Object-oriented programming is provided by
Meroon v3. The main goal of Bigloo is to deliver small and fast stand
alone applications. Bigloo produces ANSI C and hence should be easy
to port. It runs on Sparc (1, 2, 10), SONY-NEWS (MIPS R3000), IRIS
Indigo (MIPS R3000), Sun 3/60, DecStation 3100, PC-486 (linux), and
HP-PA (730). It is available by anonymous ftp from
ftp.inria.fr:/INRIA/Projects/icsla/Implementations/ [192.93.2.54]
as the files bigloo1.7.tar.gz and camloo0.2.tar.gz.
For further information, send email to Manuel....@inria.fr, or
write to Manuel Serrano (equipe ICSLA, Bat 8), INRIA-Rocquencourt,
BP 105, 78153, Le Chesnay CEDEX, FRANCE, or call 39-63-57-32.

Elk (Extension Language Kit) has been designed specifically as an
embeddable, reusable extension language subsystem for applications written
in C or C++. Elk is also useful as a stand-alone Scheme implementation,
in particular as a platform for rapid prototyping of X11-based Scheme
programs. Elk was first published in 1989; the current version is Elk 3.0.
The Elk distribution includes a Scheme interpreter (embeddable and
stand-alone versions), several dynamically loadable extensions, run-time
support (including a top-level implemented in Scheme and a debugger),
and 230+ pages of documentation (troff and PostScript format).
Major features of Elk are incremental, dynamic loading of compiled
extensions (supported on many platforms); freezing of the interpreter or
application into a new executable file; a C/C++ programmer's interface
for language interoperability; Scheme bindings for X11 Xlib, Xt, Athena
and Motif Widgets; a UNIX interface (not restricted to POSIX); bitstrings,
records, and regular expressions; a stop-and-copy and an incremental,
generational garbage collector.
The Elk 3.0 distribution and more information about Elk are available
in the World Wide Web at
http://www.informatik.uni-bremen.de/~net/elk
The distribution is also available on a number of FTP sites including
ftp://ftp.x.org/contrib/devel_tools/elk-3.0.tar.gz
ftp://ftp.uni-bremen.de/pub/programming/languages/scheme/elk/elk-3.0.tar.gz
For more information contact Oliver Laumann <n...@cs.tu-berlin.de>.

FDU Scheme is a R3RS implementation of Scheme for the Prime
50-series under Primos. It is available by anonymous ftp from
fdumad.fdu.edu [132.238.1.1] (username "anonymous", password
<RETURN>). Attach to the Scheme subdirectory (cd '*>scheme') and
transfer all files in it and its subdirectories using file type
binary. For more information, contact Peter Falley,
<fal...@fdumad.fdu.edu>.

Fools' Lisp is a small Scheme interpreter that is R4RS conformant, and


is available by anonymous ftp from

scam.berkeley.edu:/pub/src/local/fools.1.3.2.tar.Z [128.32.138.1]
Fools' Lisp runs on Sun3 and Sun4 (SunOs), DecStation 3100s, Vax
(Ultrix), Sequent, and Apollo. Implemented by Jonathan Lee
<jona...@scam.berkeley.edu>.

Gambit is a high-performance implementation of Scheme based on an
optimizing compiler. It conforms to the IEEE-Scheme standard (IEEE
P1178) and the Revised^4 Report on Scheme (R4RS) and supports the
whole numeric tower (i.e. integer, rational, real and complex numbers).
Gambit extends the standards by providing: weak pairs, wills, string
ports, records, property lists, namespaces, futures, pretty printer,
debugger, multitasking, and compiler declarations. To make it portable
and simplify bootstrapping, the compiler is written in IEEE-Scheme and
makes use of a high-level abstract-machine (called GVM) for the
intermediate representation. A "Scheme-in-Scheme" approach was adopted
to minimize the amount of non-portable code in the system (nearly all of
the runtime library is written in Scheme including the interpreter and
debugger). Three different variants of Gambit were produced:

Gambit-68K (first public release in 1990; last version: 2.0, june 1993):
This is the original Gambit system with a native code back-end
for Motorola 680x0. It works on most 68K based Unix workstations
and on the BBN GP1000 shared-memory multiprocessor. The back-end
for the GP1000 implements Multilisp's "future" parallel construct
using lazy-task-creation (a very low overhead task spawning
mechanism).
ftp.iro.umontreal.ca:/pub/parallele/gambit/gamb68k.tar.Z

MacGambit (first public release in 1991; last version: 2.2.2, oct 1995):
This is a port of Gambit-68K for the Macintosh. It is a complete
development environment, including a Scheme-aware editor, an online
help system, and a linker to build standalone applications. A
drawing window for simple graphics and an interface to many of the
Macintosh's "Toolbox" routines are available. An executable
MacGambit application is supplied with the distribution as well as
all the sources (ThinkC 4.0 or CodeWarrior 6 or higher are needed to
recompile the sources).
ftp.iro.umontreal.ca:/pub/parallele/gambit/MacGambit.sea.hqx

Gambit-C (first public release in 1994; last version: 2.3.1, april 1996):
In this variant of Gambit, the compiler generates highly portable
C code that is reasonably efficient. The primary goals of Gambit-C
are portability and correctness (in particular it correctly implements
tail-recursion across modules and uses a precise garbage-collector).
Gambit-C runs on a wide range of Unix workstations, on Macintosh, and
DOS/Windows. It also supports these features: dynamic-loading
of compiled files, C-interface (FFI), and a memory management system
that expands and contracts the heap based on the program's needs.
Standalone executables can be created with Gambit-C (a minimal
application is about 700 Kbytes when statically linked and 5 Kbytes
when the runtime system is compiled as a shared-library).
Sources:
ftp.iro.umontreal.ca:/pub/parallele/gambit/gambc.tar.gz
Executables for Windows-95 and Windows-NT:
ftp.iro.umontreal.ca:/pub/parallele/gambit/gambc.zip
Executables for DOS and Windows 3.1:
ftp.iro.umontreal.ca:/pub/parallele/gambit/gambcdos.zip

Gambit can be used freely for non-commercial uses (including academic
research and education). A license is required to use Gambit
commercially (contact gam...@iro.umontreal.ca).

HELP (a lazy Scheme) is available by anonymous ftp from
sumex-aim.stanford.edu:/info-mac/lang/lazy-scheme.hqx. Written by
Thomas Schiex (sch...@cert.fr, sch...@irit.fr). Help is a complete and
efficient Scheme-like functional lazy Lisp interpreter. It works only
on 68020 (or more) based Macintoshes. It has a 'friendly' interface
(parenthesis matcher, auto-indent), uses a full call-by-need semantics
and includes many examples, including a symbolic compiler for the
680x0. Efficiency is good and lazyness is fully parametrizable (you
may turn Help into a strict Scheme-like language if you like). French
AND English updated docs are included in Word4 and plain text formats.

LIBSCHEME is a C library implementing Scheme as described in R4RS. It
is easily integrated into a C program as a command interpreter or
extension language, and is easily extended in C with new primitive
types, primitve functions and syntax. It should be portable to most
machines with an ANSI C compiler. It is available by anonymous ftp
from
ftp.cs.indiana.edu:/pub/scheme-repository/imp/
For more information, write to Brent Benson
<b...@concentra.com>.

MIT Scheme (aka C-Scheme), is available free by anonymous FTP from
swiss-ftp.ai.mit.edu:/archive/scheme-7.3 [18.23.0.16]
or
ftp.cs.indiana.edu:/pubscheme-repository/imp/MIT-Scheme-7.3/doc
Version 7.3 is a beta version and runs on DEC Alpha, DECStation
(MIPS), HP 9000 300/400/700, IBM RS-6000, Intel i386/i486 (DOS, NT,
Windows 3.1, or Linux), NeXT (NeXTOS 2 or 3), SGI (MIPS), Sony NEWS
(MIPS), Sun3 (SunOS 4.1) and Sun4 (SunOS 4.1). Bugs should be
reported to bug-c...@martigny.ai.mit.edu (for the DOS version, send
bug reports to bug-csc...@martigny.ai.mit.edu). MIT Scheme
includes Edwin (Scheme's Emacs-like editor) and Liar (the Scheme
compiler). Does not have a convenient foreign function interface yet.
FTP distribution includes MIT C-Scheme Reference and User manuals, as
well as the Revised^4 Report on Scheme. Discussion occurs on the
newsgroup comp.lang.scheme.c (gatewayed to the mailing list
info-c...@zurich.ai.mit.edu). For DOS floppy distribution requests
(includes printed copies of manuals), send $95.00 (payable in U.S.
funds to "Scheme Distribution") to cover costs of distribution to
Scheme Distribution, c/o Prof. Hal Abelson, 545 Technology Sq. rm 410,
Cambridge MA 02139, USA.
|
On the NeXT, MIT Scheme is available as part of the Schematik
package, which provides an editor/front-end user interface,
graphics, and "robotics" support for Lego and the like. Schematik is
free and is available for anonymous ftp from
ftp.gac.edu:/pub/next/scheme/
Europeans can get it more locally from
ftp.informatik.uni-muenchen.de:/pub/next/ProgLang/
start with Schematik-1.1.5.1.README . Schematik is also apparently
included on NeXT's "Educational Software Sampler" CD-ROM.
|
A preliminary unofficial port of C-Scheme to the Linux is available
from artemide.dei.unipd.it:/linux/scheme-7.2/. Contact the author
Matteo Frigo <Matteo...@dei.unipd.it> for more information.

MzScheme is a Scheme implementation for Unix, Windows (Win32), and
MacOS. In addition to supporting standard R4RS Scheme (including the
full numerical tower), MzScheme provides pre-emptive threads,
generative record datatypes, an exception system (integrated with all
primitive errors), classes and objects, first-class compilation units,
regular expression parsing, and simple TCP support on all platforms.
MzScheme can dynamically load extensions implemented in C, and it
can be embedded into any C/C++ application. Interoperability with C is
facilitated by the use of a conservative garbage collector.
MzScheme is the core interpreter for MrEd, an engine for developing
portable GUI applications for X Windows, Windows, and MacOS. DrScheme
(currently under development, using MzScheme/MrEd) will incorporate
project management, debugging, and modular analysis to provide a
complete Scheme development environment for pedagogical and
professional use.
For information and online documentation for MzScheme, MrEd, and
DrScheme, see
http://www.cs.rice.edu/CS/PLT/packages/drscheme/

Oaklisp is an seamless integration of Scheme with an object-oriented
substrate. Available by anonymous ftp from
f.gp.cs.cmu.edu:/usr/bap/oak/ftpable/ [128.2.250.164]
or from
ftp.cs.cmu.edu:/afs/cs.cmu.edu/user/bap/oak/ftpable/
and includes reference and implementation manuals. Written by Barak
Pearlmutter <b...@cse.ogi.edu> and Kevin Lang <ke...@research.nj.nec.com>.

PC-Scheme (aka PCScheme, PC Scheme) is an implementation of Scheme
originally written by Texas Instruments. TI made a version of the
source code freely distributable in 1987. TI stopped supporting
the code, and some researchers at the University of Geneva produced
a cleaned-up version (see PCS/Geneva below). On July 13, 1992, Ibuki
announced that it had purchased the rights to PC Scheme from TI.
Please see the Ibuki PC Scheme entry in [2-2]. If you want a
high-quality and supported implementation of PC Scheme, buy the
Ibuki implementation. It is certainly inexpensive enough. Now TI
PC-Scheme is available by anonymous ftp from
swiss-ftp.ai.mit.edu:/archive/pc-scheme/
and runs on MS-DOS 286/386 IBM PCs and compatibles. Version 3.3
should run on the 486, but no guarantees. Version 3.3 is the last
free version. TI PC-Scheme conforms to the Revised^3 Report on Scheme.
It includes an optimizing compiler, an emacs-like editor, inspector,
debugger, performance testing, foreign function interface, window
system and an object-oriented subsystem. It also supports the dialect
used in Abelson and Sussman's SICP.

PCS/Geneva is a cleaned-up version of Texas Instrument's PC Scheme
developed at the University of Geneva. The main extensions to PC
Scheme are 486 support, BGI graphics, LIM-EMS pagination support, line
editing, mouse support, assembly-level interfacing, and several
powerful Scheme-oriented editors. (TI's PC Scheme gives users full
Revised^3 support along with many primitives for DOS, Graphics and
Text Windows. A powerful built-in optimizing compiler produces fast
code.) PCS/Geneva 4.02PL1 has been tested on XTs, ATs, AT386s and
AT486s under various DOS and OS/2 versions. It even runs on
Hewlett-Packard's HP95LX. It also runs on Suns with a DOS emulator.
PCS/Geneva is available free by anonymous ftp from
cui.unige.ch:/PUBLIC/pcs/ [129.194.70.1]
as the files pcscheme.doc, pcscheme.exe, pcscheme.fil and pcscheme.taz
or by email (uuencoded) from sche...@cui.unige.ch. If you ftp
PCS/Geneva, please send mail to sche...@cui.unige.ch; the authors
like to know their public and will inform you when a new release is
available. This is also the email address for bug reports or if you
need any kind of help. This product may be distributed freely and
used without restrictions except for military purposes.
(PCS/Geneva was developed by Larry Bartholdi <lba...@cui.unige.ch>
and Marc Vuilleumier <mvui...@cui.unige.ch>.)

Pixie Scheme for the Macintosh is a nearly complete implementation of
R3RS available by anonymous ftp from
rascal.ics.utexas.edu:/misc/mac/programming/
Pixie.Goodies.SIT.bin
Pixie.NoFPP.world.SIT.bin
Pixie.world.SIT.bin
PixieScheme.NoFPP.SIT.bin ; for macs without floating-point coprocessor
PixieScheme.SIT.bin ; for macs with FPP
Pixie_Scheme_Help.SIT.bin
Pixie_intro
Written by Jay Reynolds Freeman <fre...@MasPar.COM>, P. O. Box 60628,
Palo Alto, CA, 94306-0628. A copy may also be obtained from
/afs/umich.edu/group/itd/archive/mac/development/languages
as the file pixiescheme.cpt.hqx if your site runs the Andrew File System,
or by anonymous ftp from mac.archive.umich.edu.

Scheme->C is an R4RS compliant Scheme system that is centered around
a compiler that compiles Scheme to C. Besides the base language,
the system includes "expansion passing style" macros, a foreign function
call capability, records, weak pointers, 3 X11 interfaces, call/cc, and a
generational, conservative, copying garbage collector. The result is a
system that is portable, efficient, and able to build applications that
contain a mix of compiled and interpreted Scheme, and compiled code
from C, C++ and other languages. The current release of Scheme->C runs
on the following systems: Digital Alpha AXP systems with OSF/1, MIPS
based DECstations, VAXen with ULTRIX, MIPS based SGI systems, PC's
running Microsoft Windows 3.1, Apple Macintosh's running system 7.1,
HP 9000/300, HP 9000/700, Sony News, Harris Nighthawk and other m88k
systems, linux, Sun SPARC, and NT (Visual C++ compiler). Earlier
releases also run on Sun3, DNx500, DN1000, 386's running Unix,
DNx500, and DN1000 systems. The software is available for
anonymous ftp from
gatekeeper.dec.com:/pub/DEC/Scheme-to-C/ [16.1.0.2]
There are three interfaces to X11, all written in Scheme, available
from gatekeeper. The first is a complete set of stubs to Xlib included
in the base system. The second is an alternative to Xlib called SCIX,
found in
gatekeeper.dec.com:/pub/X11/contrib/
The third, ezd, allows programs to easily
produce interactive, structured graphics and is found in
gatekeeper.dec.com:/pub/DEC/ezd/
Those without ftp access can also obtain Scheme->C and ezd from the
Prime Time Freeware CD, Vol. 1, No. 2. Additional information is
available from the author at Digital Equipment Corporation's Western
Research Lab: Joel Bartlett, bart...@decwrl.dec.com.

Scheme 48 is a Scheme implementation based on a virtual machine
architecture. Scheme 48 is designed to be straightforward, flexible,
reliable, and fast. It should be easily portable to 32-bit
byte-addressed machines that have POSIX and ANSI C support.
In addition to the usual Scheme built-in procedures and a development
environment, library software includes support for hygienic macros (as
described in the Revised^4 Scheme report), multitasking, records,
exception handling, hash tables, arrays, weak pointers, and FORMAT.
Scheme 48 implements and exploits an experimental module system
loosely derived from Standard ML and Scheme Xerox. The development
environment supports interactive changes to modules and interfaces.
A beta release of Scheme 48 is available by anonymous ftp from
ftp.cs.indiana.edu:/pub/scheme-repository/imp/scheme48-0.36.tar.Z
swiss-ftp.ai.mit.edu:/archive/s48/scheme48-0.36.tar.gz
ftp.cs.cmu.edu:/user/ai/lang/scheme/impl/s48/scheme48.tar.gz
For more information, contact Richard Kelsey and Jonathan Rees
at <scheme-4...@martigny.ai.mit.edu>.

Scsh is a Unix shell/systems programming environment implemented on top of
Scheme 48 (a portable, byte-code compiled R4RS Scheme implementation). Scsh
provides

- A high-level macro notation for writing typical shell-script
computations: running programs, pipelines, I/O redirection, and so
forth. For example, to decompress a file and mail it to someone,
you might say
(run (| (gzcat home.html.gz)
(mail -h "Here's my home page" shi...@lcs.mit.edu)))

To spell check your paper, printing out the results, you could say:
(run (| (delatex (< paper.tex))
(spell)
(lpr -Ppulp)))

- A complete system-call interface to Unix: fork, exec, I/O, file
system, time, env vars, and so forth. The I/O interface includes
a *complete* interface to BSD sockets, both Unix and TCP/IP domains.
I/O is completely integrated with Scheme ports. System calls return
useful values, not error codes; errors are reported by raising
exceptions which can be caught by handlers.

- Other useful shell-programming utilities: filename globbing/pattern
matching, regexp matching, macros for writing AWK-like programs, field
and record parsers, and so forth.

- The ability to write executable shell scripts using the Unix #!
interpreter feature, with access to command-line argv values.

These features are completely integrated into Scheme 48's R4RS Scheme
implementation; the programming language is Scheme. The scsh release
is self-contained -- it comes with its own complete Scheme 48
implementation. Scsh currently runs on the following platforms: DEC Ultrix,
Harris NightHawk, HP-UX, IBM AIX, Linux, NetBSD/i386, NeXTSTEP/Intel,
SGI IRIX, Solaris, and SunOS. It's not hard to port scsh to new systems.
|
You can get a copy of scsh via anonymous ftp, from the following:
ftp://clark.lcs.mit.edu/pub/su/scsh/scsh.tar.gz
ftp://swiss-ftp.ai.mit.edu/pub/su/scsh/scsh.tar.gz
These tar files include a detailed manual and a paper describing
the design of the system. For the lazily curious, we also have the
manual separately available as
ftp://clark.lcs.mit.edu/pub/su/scsh/scsh-manual.ps
ftp://swiss-ftp.ai.mit.edu/pub/su/scsh/scsh-manual.ps
Scsh has been implemented by the Scheme Underground
http://www.ai.mit.edu/projects/su/su.html
For further information, contact Olin Shivers <shi...@lcs.mit.edu>,
http://clark.lcs.mit.edu/~shivers/home.html


SCM, free by anonymous ftp from
swiss-ftp.ai.mit.edu:/archive/scm/
prep.ai.mit.edu:/pub/gnu/jacal/
ftp.cs.indiana.edu:/pub/scheme-repository/new/
ftp.maths.tcd.ie:/pub/bosullvn/jacal/
Current version 4e1. Runs on Amiga, Atari-ST, MacOS, MS-DOS, OS/2,
NOS/VE, VMS, Unix and similar systems. SCM conforms to the Revised^4
Report on the Algorithmic Language Scheme and the IEEE P1178
specification. Scm is written in C. ASCII and EBCDIC are supported.
Written by Aubrey Jaffer.
To receive an IBM PC floppy disk with the source files and MSDOS
and i386 executables send $99 to Aubrey Jaffer, 84 Pleasant Street,
Wakefield MA 01880, <jaf...@zurich.ai.mit.edu>.
SLIB (Standard Scheme Library) is a portable Scheme library
which is intended to provide compatability and utility functions for
all standard Scheme implementations, including SCM, Chez, Elk,
Gambit, MacScheme, MITScheme, scheme->C, Scheme48, T3.1, and VSCM, and is
available as the file slib2a0.tar.gz. Written by Aubrey Jaffer.
JACAL is a symbolic math system written in Scheme, and is
available as the file jacal1a4.tar.gz.
SCMCONFIG contains additional files for the SCM distribution to build
SCM on Unix machines using GNU autoconf.
SLIB-PSD is a portable debugger for Scheme (requires emacs editor).
TURTLSCM is a turtle graphics package which works with SCM on MSDOS
or X11 machines. Written by Mkinen Sami <s...@cc.tut.fi> and Jarkko
Leppanen <j...@cc.tut.fi>, it is available as the file turtlegr.tar.Z.
(Also available from modeemi.cs.tut.fi:/pub/scm/ as turtlegr.tar.gz,
along with an already-compiled MSDOS binary of scm with turtlegraphics
and slib in scm4c0_b.zip.)
XSCM is an X Windows interface to Xlib and the Motif and
OpenLook toolkits for the SCM interpreter. It requires scm4a10 or
later. It should be available at any archive of alt.sources, or on
swiss-ftp, prep and indiana as the file xscm1.05.tar.Z.
Contact camp...@redsox.bsw.com for more information.
SMG-SCM is a package that adds VMS SMG screen management routines
to SCM. It is available from swiss-ftp, prep and indiana as the file
sgm-scm2a1.zip. (A VMS version of Unzip is available by anonymous
FTP from ftp.spc.edu:[ANONYMOUS.MACRO32]UNZIP.EXE.) This file
contains the source code, documentation, and example code. Send
comments and bugs to T. Kurt Bond, <t...@mtnet2.wvnet.edu> (preferred)
or <Kurt...@launchpad.unc.edu>.
WB is a disk based, sorted associative array C library (database). These
associative arrays consist of variable length (less that 256 bytes)
keys and values. WB comes with an interface to SCM. Basic
operations are creation, destruction, opening and closing of
diskfiles and arrays, insertion, deletion, retrieval, successor, and
predecessor (with respect to dictionary order of keys). Functional
application of find-next, deletion, and modification over a range of
consecutive key values is supported. Multiple associative arrays
can be stored in one disk file. Simultaneous access to multiple
disk files is supported. A structure checker, garbage collector
are included. A repair program and ram-disk type file (for
temporary structures) are in developement. The current WB
implementation has a file size limit of 2^32 * block size (default
2048) = 2^43 bytes (8796 Gbytes). WB does its own memory and disk
management. WB is available on swiss-ftp, prep, and indiana as wb1a1.tar.z.

A Windows version of Scheme called WinScm is forthcoming from
Vincent Manis of Langara College of BC, Canada.

Hobbit is a Scheme-to-C compiler that works with the SCM Scheme
interpreter. It treats SCM as a C library and integrates compiled
functions into SCM as new primitives. Hobbit release 2 works with SCM
release 4b4. Future releases of SCM and Hobbit will be coordinated.
Hobbit imposes strong restrictions on the higher-order features of
Scheme. For example, it does not support continuations. The main aim
of hobbit is to produce maximally fast C programs which would retain
most of the original Scheme program structure, making the output C
program readable and modifiable. Hobbit is written in Scheme and is
able to self-compile. Hobbit can be obtained via anonymous ftp from
swiss-ftp.ai.mit.edu:/archive/scm/hobbit2.tar.Z
prep.ai.mit.edu:/pub/gnu/jacal/hobbit2.tar.Z
ftp.cs.indiana.edu:/pub/scheme-repository/new/hobbit2.tar.Z
For further information, contact the author, Tanel Tammet, at
<tam...@cs.chalmers.se> or at Tanel Tammet, Department of Computer
Sciences, Chalmers University of Technology, S-41296 Go"teborg, Sweden.

Similix is a Self-Applicable Partial Evaluator for a Subset of Scheme.
Written by Anders Bondorf, Olivier Danvy, and Jesper J{\o}rgensen. It


is available by anonymous ftp from

ftp.cs.indiana.edu:/pub/scheme-repository/imp/
as similix.tar.Z or from ftp.diku.dk:/pub/diku/dists/Similix.tar.Z. For
more information, contact Anders Bondorf, DIKU, Department of Computer
Science, University of Copenhagen, Universitetsparken 1, DK-2100
Copenhagen, Denmark, or send email to and...@diku.dk. Similix conforms
to the IEEE and R4RS standards, but also runs under R3RS Scheme. It
runs in SCM, Chez Scheme and T3.1.

SIOD (Scheme in One Defun), free by anonymous ftp from
ftp.cs.indiana.edu:/pub/scheme-repository/imp/siod-v3.0-shar
ftp.std.com:/pub/gjc/siod-3.0-shar
or in any comp.sources.unix archive. Runs on VAX/VMS, VAX UNIX, Sun3,
Sun4, Amiga, Macintosh, MIPS, Cray, Windows NT/WIN32. Small scheme
implementation in C arranged as a set of subroutines that can be
called from any main program for the purpose of introducing an
interpreted extension language. Compiles to ~42K bytes of
executable. Lisp calls C and C calls Lisp transparently. Version
3.0 includes support for manipulation of Oracle and Digital RDB
relational databases (SQL interface).
Written by George Carrette <g...@paradigm.com> or <g...@world.std.com>.

STk is a R4RS Scheme interpreter which can access the Tk graphical
package. All of the commands defined by the Tk toolkit are available
to the STk interpreter, and Tk variables are reflected back into
Scheme as Scheme variables. Callback is expressed in Scheme. Includes
a CLOS-like OO extension called STklos, which provides multiple
inheritance, generic functions, multi methods, and a true meta-object
protocol. A set of classes have been defined to manipulate Tk
commands (menu, buttons, scales, canvas, canvas items) as Scheme
objects. STk runs on Sparc (SUNOS 4.1.x), Dec 5xxx (Ultrix 4.2), SGI
(Irix 4.05, 5.1.1), DEC Alpha, and Linux 1.0. STk is available by
anonymous ftp from
kaolin.unice.fr:/pub/STk-2.1.tar.gz [193.48.229.225]
Please send bug reports, comments, and questions to Erick Gallesio,
<e...@unice.fr>, Universite de Nice - Sophia Antipolis, ESSI - I3S
Route des colles, BP 145, 06903 Sophia Antipolis CEDEX, FRANCE,
phone (33) 92-96-51-53, fax (33) 92-96-51-55.
To subscribe to the mailing list, send a message with
subscribe
in the Subject field to stk-r...@kaolin.unice.fr.

T3.1 is a Scheme-like language developed at Yale. Available by
anonymous ftp from
ftp.ai.mit.edu:/pub/systems/t3.1/
T may be obtained in Europe from
nic.funet.fi:/pub/unix/languages/scheme/t3.1/
ftp.diku.dk:/pub/t3.1/
Runs on DecStations (MIPS processor) and SGI Iris, Sun4
(SPARC), Sun3, Vax/Unix. Includes a copy of the online version of the
T manual and release notes for T3.0 and T3.1. All implementations
include a foreign function (C) interface. To be informed of fixes, new
releases, etc., send your email address to t-pr...@cs.yale.edu. Bug
reports should go to t3-...@cs.yale.edu. A multiprocessing version of
T (for Encore Multimax) is available from masala.lcs.mit.edu:/pub/mult.
[The sources were last modified November 22, 1991.]

UMB Scheme is a R4RS Scheme available by anonymous ftp from
ftp.cs.umb.edu:/pub/scheme/umb-scheme-2.10.tar.Z and also in the Scheme
Repository. It includes a simple editor, debugger, Written by William
Campbell, University of Massachusetts at Boston, bi...@cs.umb.edu.

VSCM is a R4RS Scheme available by anonymous ftp from the Scheme Repository,
ftp.cs.indiana.edu:/pub/scheme-repository/imp/vscmV0r2.tar.Z [130.63.9.66]
Written by Matthias Blume, <bl...@cs.princeton.edu>. The
implementation is based on a virtual machine design with heavy support
for most of the sophisticated features of Scheme. The virtual machine
is written in ANSI-C to aid in its portability. The bytecode compiler
is written in Scheme itself. Documentation of VSCM is also available as
http://www.cs.princeton.edu/grad/Matthias_Blume/vscm.html

XScheme is available free by anonymous ftp from
ftp.uu.net:/MSDOS/languages/X-scheme
ftp.uu.net:/amiga-sources/xscheme.20.zoo
It includes an object system and is R3RS compliant.
It was written by David Michael Betz, 167 Villa Avenue #11, Los Gatos,
CA 95032, 408-354-9303 (H), 408-862-6325 (W), db...@apple.com.
XScheme is discussed in the newsgroup comp.lang.lisp.x. It may also
be found in the Scheme Repository.

Free Scheme Implementations implemented in Lisp:

Peter Norvig's book "Paradigms of AI Programming" has a chapters about
Scheme interpreters and compilers, both written in Common Lisp. The
software from the book is available by anonymous ftp from
unix.sri.com:/pub/norvig and on disk in Macintosh or DOS format from
the publisher, Morgan Kaufmann. For more information, contact: Morgan
Kaufmann, Dept. P1, 2929 Campus Drive, Suite 260, San Mateo CA 94403,
or call Toll free tel: (800) 745-7323; FAX: (415) 578-0672

PseudoScheme is available free by anonymous ftp from
ftp.cs.cornell.edu:/pub/jar/pseudo-2-9.tar.gz
swiss-ftp.ai.mit.edu:/archive/pseudo/pseudo-2-8.tar.Z
It is Scheme implemented on top of Common Lisp, and runs in Lucid,
Symbolics CL, VAX Lisp under VMS, and Explorer CL. It should be
easy to port to other Lisps. It was written by Jonathan Rees
(j...@altdorf.ai.mit.edu, j...@cs.cornell.edu). Send mail to
info-clsch...@mc.lcs.mit.edu to be put on a mailing list
for announcements. Conforms to R4RS except for lacking a correct
implementation of call/cc. It works by running the Scheme code
through a preprocessor, which generates Common Lisp code.

Scheme84 is in the public domain, and available by mail from Indiana
University. It runs on the VAX in Franz Lisp under either VMS or BSD Unix.
To receive a copy, send a tape and return postage to: Scheme84
Distribution, Nancy Garrett, c/o Dan Friedman, Department of Computer
Science, Indiana University, Bloomington, Indiana. Call 1-812-335-9770
or send mail to n...@indiana.edu for more information. It will also
run in Jeff Dalton's port of Franz Lisp to Net/Free/386BSD on 386-like
machines. (See the Lisp FAQ for information on Franz Lisp.)
Scheme84 is available by anonymous FTP from
ftp://ftp.cs.indiana.edu/pub/scheme-repository/imp/scheme84.tar.gz

Scheme88 is available by anonymous ftp from rice.edu:/public/scheme88.sh
and also from the Scheme Repository.

----------------------------------------------------------------
Subject: [2-2] Commercial Scheme implementations.

Chez Scheme:

Chez Scheme Version 5 is a high-performance implementation of Scheme
conforming to the IEEE/ANSI Scheme Standard and the R4RS. Chez Scheme
provides an incremental optimizing compiler, complete run-time library,
generation-based garbage collector, interactive inspector, and C
interface. New Version 5 features include improved performance,
lexical macros, multiple values, shared incremental heaps, guardians
and weak pairs, and generic ports. Version 5 is available for Sparc
SunOS and Solaris, Alpha OSF/1, SGI IRIX 5.X, Motorola mc88000 SVR3/4,
80386 NeXT Mach, BSDI BSD/386, and Linux. More information on Chez
Scheme can be obtained via anomymous ftp from
ftp.cs.indiana.edu:/pub/scheme/chezscheme/
Site license fees start at $9000 ($4500 academic). We are not able to
handle personal sales at this time. For detailed pricing and ordering
information contact sa...@cadence.bloomington.in.us or Kent Dybvig at
d...@cs.indiana.edu. Cadence Research Systems, 3814 Devonshire South,
Bloomington, IN 47408-9698, USA. Phone 812-333-9269, fax 812-332-4688.

EdScheme, WinScheme Editor, 3DScheme, "The Schemer's Guide", and
"The Schemer's Guide to C++":

Schemers Inc. publishes software and textbooks that promote the
use and advancement of Scheme in the educational and commercial
sectors. Their products include:

+ The WinScheme Editor v2.0. This is a Windows full-featured MDI
(Multiple Document Interface) editor for Scheme programs. It knows
about Scheme syntax and contains comprehensive code formatting
facilities. It provides a channel for sending programs direct to
Windows-based Scheme interpreters, allowing users to develop, test,
and edit Scheme code from within the editor. The WinScheme Editor
also includes a substantial set of context-sensitive online
documentation for the programming environment and the Scheme
language. The WinScheme Editor requires MS Windows 3.1 or later (with
Win32s), Windows 95 or Windows NT with 2MB RAM and 3MB hard disk space.
The retail price for the WinScheme Editor is $89.95.

+ EdScheme for Windows v4.2a. This is an R4RS-compatible Windows-based
Scheme interpreter. It is seamlessly integrated into the WinScheme
Editor and provides a fully customizable transcript window that
journals Scheme sessions and serves as a command window. EdScheme
can be customized by specifying a load-path, a start-up file of
library procedures, and setting its level of Windows multi-tasking
tolerance. EdScheme for Windows includes a turtle graphics
interface, Windows API access for creating windows, dialogs, and
interacting with the mouse, and an integrated debugging facility.
EdScheme for Windows is a 32-bit application that requires MS
Windows 3.1 or later (with Win32s), Windows 95 or Windows NT with
4MB RAM and 4MB of hard disk space. The retail price for EdScheme
for Windows is $129.95. (Note: The WinScheme Editor is integrated
into EdScheme and does not need to be ordered separately.)

+ 3DScheme for Windows v1.3. This is a Windows-based R4RS Scheme
interpreter incorporating over 550 geometrical Scheme primitives that
access Spatial Technology Inc's ACIS (R) Geometric Modeling Kernel,
the de facto industry standard in 3D modeling. The 3D modeling
features include:
- construction of solid bodies from blocks, cylinders, cone
frustums, spheres, and toruses.
- construction of wire-bodies from straight, circular,
elliptical, Bezier, and spline edges.
- construction of solids by extruding planar faces or
profiles along a vector or revolving about an axis.
- application of rigid transformations, uniform scaling, and
boolean operations.
- intersect, trim, fillet, and chain edges.
- simultaneous views of solids from several different angles.
- dynamically accepted event-driven input for picking,
rubber banding, or dragging.
- rendering of solids using flat or Gouraud technology and
configurable refinements, materials, texture spaces, and
render lights.
- saving and loading collections of solid and wire entities
from disk in .sat format.
- outputting rendered images as high resolution bitmaps or
Postscript files.
As with EdScheme for Windows, 3DScheme is seamlessly integrated with
the WinScheme Editor. 3DScheme also ships with the "Getting Started
with ACIS 3D Toolkit Using Scheme" book which is described below.
3DScheme is a 32-bit application that requires MS Windows 3.1 or
later (with Win32s), Windows 95 or Windows NT with 8MB RAM and 16MB
of hard disk space. A 3DScheme demo program is available from the
Scheme repository in the "promo" directory or may be requested from
Schemers Inc. 3DScheme for Windows retails for $495 (call for academic
discount). (Note: The WinScheme Editor is integrated into 3DScheme and
does not need to be ordered separately.)

+ EdScheme for Macintosh v4.0. This is an R4RS-compatible
Macintosh-based Scheme interpreter. The programming environment
takes advantage of the capabilities of the Macintosh computer. Its
user interface includes a full-featured integrated editor, with
special capabilities such as parenthesis-matching, program
formatting, file indexing, and template editing. In addition,
customized transcript and debugging windows featuring colored and
styled text are provided. The interpreter features a powerful and
comprehensive turtle graphics interface, unlimited precision "bignum"
integral and rational/complex number arithmetic, file handling
facilities, and language extensions using macros and transformers.
EdScheme for Macintosh runs from floppy or hard drive and requires a
Mac Plus or later, System 6.0.4 or better, and 2MB RAM. EdScheme for
Macintosh retails for $59.95.

+ EdScheme for DOS v3.4. This is a DOS-based Scheme interpreter that
incorporates a large subset of R4RS. EdScheme for DOS features an
integrated editor with automatic parenthesis-matching, a turtle
graphics interface, debugging facility, comprehensive file-handling
capabilities, macros and more. It runs from floppy or hard drive and
requires MS DOS 3.3 or later and 512KB RAM. EdScheme for DOS retails
for $49.95.

+ "The Schemer's Guide - Second Edition" by Iain Ferguson with

Edward Martin and Burt Kaufman. Foreword by Daniel Friedman.

(1995--346pp.--Paper--ISBN 0-9628745-2-3)
The Schemer's Guide presents the elements of modern computer programming
in an easy-to-follow and entertaining manner. The book introduces

students to the Scheme programming language, guiding them through such
concepts as functional programming, recursion, data structures, higher
order functions, delayed evaluation, and object-oriented programming.

The Schemer's Guide concludes with a significant game-playing project


involving artificial intelligence. The book strikes a good balance
between theory and practice, while nurturing good programming
practices. The Schemer's Guide has a proven track record of several
years use in teaching the art of Scheme programming to high school
students and college undergraduates. A comprehensive teacher's guide
and an additional set of resource materials including worksheets,
quizzes, projects, and exams are available to instructors using this

text. The retail price of the book is $35.95. (A Spanish
translation of "The Schemer's Guide" is available.)

+ "The Schemer's Guide to C++" by Iain Ferguson
(1996--92 pp.--Paper--ISBN 1-888579-11-0)
The Schemer's Guide to C++ builds on the solid theoretical foundation
provided by an increasing number of courses--such as those based on
the introductory textbook, The Schemer's Guide--that introduce the
principles of modern computer science via the Scheme language. From
this basis it provides students with a fundamental, pratical working
knowledge of the programming language C++. The author uses his
experience as a full-time, commercial programming professional to lead
students step by step from the elegant principles of high level
programming with which they are already familiar to the nitty-gritty
of C++, but without ever losing sight of the computer science
fundamentals that underlie good programming practice. As in "The
Schemer's Guide", students quickly learn to write complete,
non-trivial programs, including the design and implementation of a
modern container class library. This unashamedly practical course is
perfect for students and teachers who seek a clear, direct, fast-track
path to learning C++. The retail price of the book is $17.95.


+ "Getting Started with ACIS 3D Toolkit Using Scheme" by Edward
Martin. (1995--260pp.--Paper--ISBN 0-9628745-1-5)
This Getting Started book includes all you need to know about Scheme,
mathematics, and solid modeling to become a skilled 3D modeler using
3DScheme or the ACIS 3D Toolkit. The retail price for the book is
$35.95, but is included free with 3DScheme for Windows.

For more information about these products, write to Schemers Inc.,
2136 NE 68th Street, Suite 401, Fort Lauderdale, FL 33308, call
954-776-7376, or fax 954-776-6174. You can also send EMail to
in...@schemers.com.

Schemers' European distributor, Lambda Publications, is reachable by
phone at 44-793-695296 or by EMail on 10001...@compuserve.com.

Gambit Scheme requires a license for commercial users. See the entry
in [2-1] for details.

Ibuki PC Scheme:

Ibuki PC Scheme 5.01 is a modern, up-to-date implementation of TI
PC-Scheme (see [2-1]). Ibuki purchased the rights to TI PC Scheme
on July 13, 1992. Ibuki PC Scheme runs under DOS on all IBM
compatible PCs, including 486s, and can use up to 4mb of extended
memory. It will also run under Windows 3.1. For more information,
contact IBUKI, 340 Second Street, PO Box 1627, Los Altos, CA 94022,
phone (415) 961-4996, fax (415) 961-8016, email Richar Weyhrauch
<r...@ibuki.com>. Ibuki has a special pricing program for schools
teaching Scheme in courses.

Inlab-Scheme:

Inlab-Scheme is an independent implementation of the algorithmic
language Scheme as defined by the R4RS and the IEEE Standard
1178. In addition to the language core Inlab-Scheme has support
for bitmap/greymap processing of several kinds. Inlab-Scheme can
be used as a general tool for image processing, OCR or specialized
optical object and pattern recognition.

Inlab-Scheme is distributed at <http://www.munich.net/inlab/scheme>,
where additional information about the current state of the project,
supported platforms, current license fees and more is available.

MacScheme:

MacScheme is a Scheme interpreter and compiler for the Apple Macintosh, and
includes an editor, debugger and object system. MacScheme costs $125
(includes compiler) and Scheme Express costs $70 (interpreter only). It
requires 1mb RAM. A development environment (MacScheme+Toolsmith) costs
$495. Conforms to the Revised^4 Report on the Algorithmic Language Scheme.
MacScheme+Toolsmith includes support for menus, windows, and interfaces to
the Macintosh Toolbox, and can create small standalone Macintosh
executables. Implemented by Will Clinger, John Ulrich, Liz Heller and Eric
Ost. Write to: Lightship Software, PO Box 1636, Beaverton, OR 97075, or
call (503) 292-8765. They're moving to California. The temporary phone
number is 415-940-4008 (Liz Heller). The new phone number will be
415-694-7799, or fax bug reports to 415-694-7705 or 800-441-5015.
MacScheme is distributed by Academic Computing Specialists (ACS),
2015 East 3300 South, Salt Lake City, UT 84109-2630, 1-800-531-3227
or 1-800-552-1601 (801-484-3923), fax 801-467-2200. These products
may also be purchased from Academic Computing Specialists, PO Box
711, Dewey, AZ 86327, tel 602-632-7176, fax 602-632-7631.

----------------------------------------------------------------
Subject: [2-3] What Scheme-related discussion groups and mailing lists exist?

Before posting to any discussion group, please read the rest
of this FAQ, to make sure your question isn't already answered.

See the Lisp FAQ for a list of Lisp-related discussion groups and
mailing lists. We list here only those newsgroups and mailing lists
directly associated with Scheme.

Newsgroups:

comp.lang.scheme General Scheme-related discussion.
This newsgroup is available in digest
fromat as part of the Scheme Digest
sch...@mc.lcs.mit.edu.
comp.lang.scheme.c Discussion of C-Scheme, a scheme dialect
more commonly known as "MIT Scheme".
This newsgroup is gatewayed to the
info-c...@zurich.ai.mit.edu mailing list.
comp.lang.scheme.scsh Discussion of Scsh, the ``Scheme Shell'', a UNIX
shell/systems programming environment implemented
on top of Scheme 48 (a portable, byte-code
compiled R4RS Scheme implementation).
This newsgroup is gatewayed to the
sc...@zurich.ai.mit.edu mailing list.
comp.lang.lisp.x Discussion of XLISP, a dialect of Lisp, and XScheme.
comp.lang.dylan Discussion of Dylan (see [4-6]), Apple's
new Scheme-like programming language. Gatewayed to
info-...@cambridge.apple.com.

We list several mailing lists below. In general, to be added to
a mailing list, send mail to the "-request" version of the address.
This avoids flooding the mailing list with annoying and trivial
administrative requests. [To subscribe to info-mcl, info-dylan, or
other mailing lists based at cambridge.apple.com, send a message to
majo...@cambridge.apple.com with "subscribe <list_name>" in the
message body. Likewise use "unsubscribe <list_name>" to cancel your
subscription and "help" to get help.]


General Scheme Mailing Lists:

sch...@mc.lcs.mit.edu Discussion of Scheme. Gatewayed to
the comp.lang.scheme newsgroup.
sch...@ai.mit.edu General discussion about Scheme.


Particular Flavors of Scheme:

info-c...@altdorf.ai.mit.edu,
info-c...@zurich.ai.mit.edu C-Scheme. Gatewayed to the
comp.lang.scheme.c newsgroup.

t-pr...@cs.yale.edu T, a dialect of Scheme.

info-c...@mc.lcs.mit.edu PseudoScheme

info-...@cambridge.apple.com Dylan (not really scheme, but)

----------------------------------------------------------------
;;; *EOF*

Reply all
Reply to author
Forward
0 new messages