Scheme started as an experiment in programming language design by challenging some fundamental design assumptions. It emerged from MIT in the mid-1970's. It is a dialect of Lisp invented by Guy Lewis Steele Jr. and Gerald Jay Sussman. Originally called Schemer, it was shortened to Scheme because of a 6 character limitation on file names. Scheme is a small, exceptionally clean language which is fun to use. The language was designed to have very few, regular constucts which compose well to support a variety of programming styles including functional, object-oriented, and imperative. Scheme was influenced by lambda calculus, which is one of the first functional ``programming languages'' in the world, Algol, from which Scheme inherited statical scope and Lisp, from which Scheme inherited the syntax.
Scheme is a statically (= lexically) scoped and
The procedures in Scheme are first class procedures, which means that
they can be given as arguments to other procedures, they can be
returned as the value of a procedure, they can be bound to variables
or fields of other objects etc. The arguments of Scheme procedures are
passed by value.
Syntactically Scheme is very simple and beautiful. The syntax consists
of parentheses and
As Scheme became more widespread, local dialects began to diverge
until students and researchers occasionally found it difficult to
understand code written at other sites. Fifteen representatives of the
major implementations of Scheme therefore met in October 1984 to work
toward a better and more widely accepted standard for Scheme.
Their report (The revised revised report on Scheme, or an uncommon Lisp [RRRS])
was published at MIT and Indiana University in the
summer of 1985. Further revision took place in the spring of 1986
(The revised^3 report on the
algorithmic language Scheme [R3RS]), and in the spring
of 1988 (The revised^4 report
on the algorithmic language Scheme [R4RS]).
The present report reflects further revisions agreed upon in a meeting at
Xerox PARC in June 1992 (R5RS).
Have a look at the Scheme Standards documents section of
The Internet Scheme Repository for more details.
Scheme is a wonderful choice as an introductory language: its clear
syntax makes it possible to concentrate on the programming problems at
hand instead of wasting a lot of time on teaching the syntax. It is
also possible to teach several different programming paradigms, e.g.
functional, imperative and object oriented (message passing). Scheme is also
a very small language and is therefore easy to learn.
Hal Abelson's, Jerry Sussman's and Julie Sussman's
Structure and Interpretation of Computer Programs
(MIT Press, 1984; ISBN 0-262-01077-1),
an excellent computer science text used in introductory courses at MIT is
one of the bibles of the LISP/Scheme world. It is a good example of
the usefulness of Scheme in teaching programming concepts. Also called
Wizard Book because of the wizard on the jacket.
Also, less commonly, known as the Purple Book.
Another online book is The Scheme
Programming Language, 2nd Edition
which is a introduction to Scheme, but not to programming in general.
Schemer.org is a very comprehensive
web resource for all things Scheme.
These days, there is a huge number of Scheme implementations available.
Some people even say there are more implementations than Scheme programmers.
Guile is an interpreter
for Scheme, packaged for use in a wide variety of environments. Guile
implements Scheme as described in
R5RS,
providing clean and general data and control structures. Guile goes beyond
the rather austere language presented in R5RS, extending it with
Guile can run interactively, reading expressions from
the user, evaluating them, and displaying the results, or as a script
interpreter, reading and executing Scheme code from a file. However,
Guile is also packaged as an object library, allowing other
applications to easily incorporate a complete Scheme interpreter. An
application can use Guile as an extension language, a clean and
powerful configuration language, or as multi-purpose "glue",
connecting primitives provided by the application. It is easy to call
Scheme code from C code and vice versa, giving the application
designer full control of how and when to invoke the interpreter.
Applications can add new functions, data types, control structures,
and even syntax to Guile, creating a domain-specific language tailored
to the task at hand, but based on a robust language design.
Guile's module system allows one to break up a large program into
manageable sections with well-defined interfaces between them. Modules
may contain a mixture of interpreted and compiled code; Guile can use
either static or dynamic linking to incorporate compiled code. Modules
also encourage developers to package up useful collections of routines
for general distribution.
Dialects and standards
The first description of Scheme was written
by Gerald Jay Sussman and Guy Lewis Steele Jr., "Scheme: an interpreter for extended lambda calculus". MIT Artificial Intelligence Memo 349, December 1975.
A revised report appeared in 1978, which described the evolution of the
language as its MIT implementation was upgraded to support an innovative
compiler (Rabbit). Three distinct projects began in 1981 and 1982 to use
variants of Scheme for courses at MIT, Yale, and Indiana University.
Learning (with) Scheme
Implementations
Guile