=================[ Readings on Scheme ]=================

In the textbook, Scheme is called a dialect of LISP; others would call
it a separate language. Scheme was meant to focus on the features of
LISP that were most interesting (such as lexical scoping), clean up
unnecessary complexity (such as separate symbol-value and
symbol-function and the related funcall for calling lambdas), and to
make the syntax more uniform (uniform ending ? for predicates, uniform
ending of ! for special forms and functions that are "destructive" or
have side-effects, such as atom?, null?, set!, car!, and cdr! instead
of Lisp's atom, null, setq, rplaca, rplacd).

Scheme became the language for testing new programming language and
compiler research ideas. Being of the Lisp descent, it had minimal
syntax and could be redefined and extended at will, while still having
its programs at the same time as its most fundamental data structure
(a list). As a cleaner Lisp, it was compact and rid of some of Lisp's
legacy baggage.

Scheme is used in the famous MIT textbook:
https://mitpress.mit.edu/sicp/full-text/book/book-Z-H-4.html#%_toc_start
Alas, MIT replaced Scheme with Python as its first language
to teach programming; many deplore this decision. Gerald Sussman,
a co-creator of Scheme with Guy Steele (also a designed of Common Lisp)
had some remarks on why this decision was made:
https://cemerick.com/2009/03/24/why-mit-now-uses-python-instead-of-scheme-for-its-undergraduate-cs-program/
It may perhaps be simply the observation that a language
with fewer libraries loses to a language with plentiful (free) libraries.

----------------[ From Lisp to Scheme code ]----------------

For brief but informative translations between Scheme and Lisp see
the end of textbook's section 3.3. Figure 20.1 in Chapter 20 of OnLisp
is more comprehensive.

Chapter 20 talks of "continuations", another core PL concept after
closures and lexical scoping newly introduced in Scheme.

MacPorts has several Scheme implementations: scheme48, mit-scheme, etc.
See https://wingolog.org/archives/2013/01/07/an-opinionated-guide-to-scheme-implementations
if you are interested in exploring; Racket has a GUI and an IDE if you like these.
Otherwise, use any command-line Scheme with "rlwrap" ("port install rlwrap").


You best quick intro to Scheme may be looking at how the Y-combinator looks
in it: https://rosettacode.org/wiki/Y_combinator#Scheme . Run it in your
Scheme to be sure :)

----------------[ Common Lisp ]----------------

Common Lisp also went to lexical scoping and closures, but
it also added an object system (the Common Lisp Object System, CLOS),
and many standard libraries. CLOS is described in
"Common Lisp the Language" by Guy Steele (freely available
at https://www.cs.cmu.edu/Groups/AI/html/cltl/cltl2.html);
http://cl-cookbook.sourceforge.net/clos-tutorial/ is a good quick intro.


In my Mac-based explorations, "Steel Bank Common Lisp" (SBCL) with
QuickLisp (https://www.quicklisp.org/beta/) for package management
and the Slime Emacs environment to run it (installed through
QuickLisp, as described in
http://stackoverflow.com/questions/12607716/setting-the-slime-in-emacs)
was the most convenient environment.