\clearextrapart{Introduction}

\label{historysection}

Programming languages should be designed not by piling feature on top of
feature, but by removing the weaknesses and restrictions that make additional
features appear necessary.  Scheme demonstrates that a very small number
of rules for forming expressions, with no restrictions on how they are
composed, suffice to form a practical and efficient programming language
that is flexible enough to support most of the major programming
paradigms in use today.

Scheme
was one of the first programming languages to incorporate first-class
procedures as in the lambda calculus, thereby proving the usefulness of
static scope rules and block structure in a dynamically typed language.
Scheme was the first major dialect of Lisp to distinguish procedures
from lambda expressions and symbols, to use a single lexical
environment for all variables, and to evaluate the operator position
of a procedure call in the same way as an operand position.  By relying
entirely on procedure calls to express iteration, Scheme emphasized the
fact that tail-recursive procedure calls are essentially gotos that
pass arguments.  Scheme was the first widely used programming language to
embrace first-class escape procedures, from which all previously known
sequential control structures can be synthesized.  A subsequent
version of Scheme introduced the concept of exact and inexact number objects,
an extension of Common Lisp's generic arithmetic.
More recently, Scheme became the first programming language to support
hygienic macros, which permit the syntax of a block-structured language
to be extended in a consistent and reliable manner.

\subsection*{Guiding principles}

To help guide the standardization effort, the editors have adopted a
set of principles, presented below.
Like the Scheme language defined in \rrs{5}~\cite{R5RS}, the language described
in this report is intended to:

\begin{itemize}
\item allow programmers to read each other's code, and allow
  development of portable programs that can be executed in any
  conforming implementation of Scheme;

\item derive its power from simplicity, a small number of generally
  useful core syntactic forms and procedures, and no unnecessary
  restrictions on how they are composed;
  
\item allow programs to define new procedures and new hygienic
  syntactic forms;
  
\item support the representation of program source code as data;
  
\item make procedure calls powerful enough to express any form of
  sequential control, and allow programs to perform non-local control
  operations without the use of global program transformations;
  
\item allow interesting, purely functional programs to run indefinitely
  without terminating or running out of memory on finite-memory
  machines;
  
\item allow educators to use the language to teach programming
  effectively, at various levels and with a variety of pedagogical
  approaches; and

\item allow researchers to use the language to explore the design,
  implementation, and semantics of programming languages.
\end{itemize}

In addition, this report is intended to:

\begin{itemize}
\item allow programmers to create and distribute substantial programs
  and libraries, e.g., implementations of Scheme Requests for
  Implementation, that run without
  modification in a variety of Scheme implementations;
  
\item support procedural, syntactic, and data abstraction more fully
  by allowing programs to define hygiene-bending and hygiene-breaking
  syntactic abstractions and new unique datatypes along with
  procedures and hygienic macros in any scope;
  
\item allow programmers to rely on a level of automatic run-time type
  and bounds checking sufficient to ensure type safety; and

\item allow implementations to generate efficient code, without
  requiring programmers to use implementation-specific operators or
  declarations.
\end{itemize}

While it was possible to write portable programs in Scheme as
described in \rrs{5}, and indeed portable Scheme programs were written
prior to this report, many Scheme programs were not, primarily because
of the lack of substantial standardized libraries and the
proliferation of implementation-specific language additions.

In general, Scheme should include building blocks that allow a wide
variety of libraries to be written, include commonly used user-level
features to enhance portability and readability of library and
application code, and exclude features that are less commonly used and
easily implemented in separate libraries.

The language described in this report is intended to also be backward
compatible with programs written in Scheme as described in \rrs{5} to
the extent possible without compromising the above principles and
future viability of the language.  With respect to future viability,
the editors have operated under the assumption that many more Scheme
programs will be written in the future than exist in the present, so
the future programs are those with which we should be most concerned.

\subsection*{Acknowledgements}

Many people contributed significant help to this revision of the
report.  Specifically, we thank Aziz Ghuloum and Andr\'e van Tonder for
contributing reference implementations of the library system.  We
thank Alan Bawden, John Cowan, Sebastian Egner, Aubrey Jaffer, Shiro
Kawai, Bradley Lucier, and Andr\'e van Tonder for contributing insights on
language design.  Marc Feeley, Martin Gasbichler, Aubrey Jaffer, Lars T Hansen,
Richard Kelsey, Olin Shivers, and Andr\'e van Tonder wrote SRFIs that
served as direct input to the report.  Marcus Crestani, David Frese, 
Aziz Ghuloum, Arthur A.\ Gleckler, Eric Knauel, Jonathan Rees, and Andr\'e
van Tonder thoroughly proofread early versions of the report.

We would also like to thank the following people for their
help in creating this report: Lauri Alanko,
Eli Barzilay, Alan Bawden, Brian C.\ Barnes, Per Bothner, Trent Buck,
Thomas Bushnell, Taylor Campbell, Ludovic Court\`es, Pascal Costanza,
John Cowan, Ray Dillinger, Jed Davis, J.A.\ ``Biep'' Durieux, Carl Eastlund,
Sebastian Egner, Tom Emerson, Marc Feeley, Matthias Felleisen, Andy
Freeman, Ken Friedenbach, Martin Gasbichler, Arthur A.\ Gleckler, Aziz
Ghuloum, Dave Gurnell, Lars T Hansen, Ben Harris, Sven Hartrumpf, Dave
Herman, Nils M.\ Holm, Stanislav Ievlev, James Jackson, Aubrey Jaffer,
Shiro Kawai, Alexander Kjeldaas, Eric Knauel, Michael Lenaghan, Felix Klock,
Donovan Kolbly, Marcin Kowalczyk, Thomas Lord, Bradley Lucier, Paulo
J.\ Matos, Dan Muresan, Ryan Newton, Jason Orendorff, Erich Rast, Jeff
Read, Jonathan Rees, Jorgen Sch\"afer, Paul Schlie, Manuel Serrano,
Olin Shivers, Jonathan Shapiro, Jens Axel S\o{}gaard, Jay Sulzberger,
Pinku Surana, Mikael Tillenius, Sam Tobin-Hochstadt, David Van Horn,
Andr\'e van Tonder, Reinder Verlinde, Alan Watson, Andrew Wilcox, Jon
Wilson, Lynn Winebarger, Keith Wright, and Chongkai Zhu.

We would like to thank the following people for their help in creating
the previous revisions of this report: Alan Bawden, Michael
Blair, George Carrette, Andy Cromarty, Pavel Curtis, Jeff Dalton, Olivier Danvy,
Ken Dickey, Bruce Duba, Marc Feeley,
Andy Freeman, Richard Gabriel, Yekta G\"ursel, Ken Haase, Robert
Hieb, Paul Hudak, Morry Katz, Chris Lindblad, Mark Meyer, Jim Miller, Jim Philbin,
John Ramsdell, Mike Shaff, Jonathan Shapiro, Julie Sussman,
Perry Wagle, Daniel Weise, Henry Wu, and Ozan Yigit.

We thank Carol Fessenden, Daniel
Friedman, and Christopher Haynes for permission to use text from the Scheme 311
version 4 reference manual.  We thank Texas Instruments, Inc.~for permission to
use text from the {\em TI Scheme Language Reference Manual}~\cite{TImanual85}.
We gladly acknowledge the influence of manuals for MIT Scheme~\cite{MITScheme},
T~\cite{Rees84}, Scheme 84~\cite{Scheme84}, Common Lisp~\cite{CLtL},
Chez Scheme~\cite{csug7}, PLT~Scheme~\cite{mzscheme352},
and Algol 60~\cite{Naur63}.

\vest We also thank Betty Dexter for the extreme effort she put into
setting this report in \TeX, and Donald Knuth for designing the program
that caused her troubles.

\vest The Artificial Intelligence Laboratory of the
Massachusetts Institute of Technology, the Computer Science
Department of Indiana University, the Computer and Information
Sciences Department of the University of Oregon, and the NEC Research
Institute supported the preparation of this report.  Support for the MIT
work was provided in part by
the Advanced Research Projects Agency of the Department of Defense under Office
of Naval Research contract N00014-80-C-0505.  Support for the Indiana
University work was provided by NSF grants NCS 83-04567 and NCS
83-03325.


%%% Local Variables: 
%%% mode: latex
%%% TeX-master: "r6rs"
%%% End: 
