=================[ 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. For example, Scheme introduced the
uniform ending ? for predicates, such as atom?, null? (instead if
LISP's atom and null), and the uniform ending of ! for special forms
and functions that are "destructive" or have side-effects, such as
set!, car!, and cdr!  (instead of LISP's setq, rplaca, rplacd).

Scheme became the language for testing new programming languages and
compiler research ideas. Being of the Lisp descent, it had minimal
syntax and could be redefined and extended at will, due to its
programs being at the same time its most fundamental data structure: a
list of cons cells, a sexp. As a cleaner LIST, 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 (who was also a designer of Common Lisp) has
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/
These may, perhaps, simply amount to the observation that a language
with fewer libraries loses to a language with plentiful (free)
libraries---or it may, in fact, go deeper. You be the judge.

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

For a brief but informative summary of differences 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 evolution ]----------------

Common Lisp also went to lexical scoping and closures, but it also
added an object system: CLOS, the Common Lisp Object System, as the
Object-oriented programming (OOP) paradigm gained ground in industry.

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)
made for the most convenient Common Lisp environment.