Scheme books
← Back up
This page seeks to collect and list English–language Scheme books in one
place for easy access.
See the notes at the bottom for additional
information.
Books
Scheme
Books that teach Scheme itself:
-
TSPL
— The Scheme Programming Language (2009)
This book is simultaneously a comprehensive language reference and a
learning source. The book flows sequentially and introduces new
concepts step by step with exercises and example use–cases.
Difficulty: Easy. It assumes no knowledge of Scheme in the
first sections, which you can skip if you consider yourself
well–versed in the language.
Recommended implementation: Chez Scheme or any other R6RS
conformant Scheme.
-
Realm of Racket (2013)
Recommended implementation: Racket.
-
Racket Programming the Fun Way (2021)
Recommended implementation: Racket.
-
Teach Yourself Scheme in Fixnum Days (2005)
Recommended implementation: Any R5RS conformant Scheme.
-
Simply Scheme:
Introducing Computer Science (1999)
Recommended implementation: Any IEEE or R5RS conformant Scheme.
The author seems to be using SCM.
-
Sketchy Scheme:
An Introduction to Functional Programming (2011)
Recommended implementation: Any R5RS conformant Scheme.
-
Server: Racket:
Practical Web Development with the Racket HTTP Server (2017)
Recommended implementation: Racket.
-
Racket Weekend (2022)
Recommended implementation: Racket.
-
A Pamphlet against R:
Computational Intelligence in Guile Scheme (2016)
Recommended implementation: Guile.
-
Learn Scheme for Max (2021)
Recommended implementation: s7.
-
Scheme: Language Essentials (2015)
Recommended implementation: Any R6RS conformant Scheme.
- Outdated books — Included for historic significance.
Computer Science
Books that teach computer science concepts using Scheme:
-
SICP
— Structure and Interpretation of Computer Programs (1996)
The time–tested classic that first comes to mind when
someone says "computer science textbook." It is a thorough
trip through fundamental principles of computer science
where you implement algorithms and data structures by
defining a high–level domain–specific language
in layers (ie "language–oriented design").
It is recommended to read the whole thing back to back even
if you consider yourself proficient.
Difficulty: Moderate. It is a fairly thick book dense in
content. You can begin reading right away with no background in
computer science, but make sure not to skip any parts you do not
understand, as it continuously builds upon previous concepts.
Recommended implementation: Racket's #lang sicp
or plain MIT/GNU Scheme.
-
HtDP
— How to Design Programs (2018)
Another university textbook that uses Scheme to teach computer
science. HtDP seeks to
address the shortcomings
of SICP in the 21st century by pulling down the initial learning curve
and breaking the book into clean–cut sections that correspond to
students' proficiency. If you consider yourself well–versed in Scheme,
you can start reading at Chapter IV.
Difficulty: Easy. It can even be used to teach algorithms to
children. It starts off gently and slowly ramps up. Some might find
the first parts too easy and boring, but you can freely skip to the
parts you feel more comfortable with.
Recommended implementation: Racket's HtDP teachpacks in DrRacket.
-
The Little Series —
A lighthearted book series featuring a hypothetical instructor with a
whiteboard asking questions to pupils and getting responses and
further questions. A high–level language is incrementally built from
the ground up in each book.
-
The Little Schemer (1995)
First book of the series. Starts from the basics and introduces
concepts one by one. The first half is dedicated to teaching
Scheme. The book gradually moves on to teach functional
programming and data structures in the second half.
Difficulty: Very easy. Probably the simplest book on this
list. With enough determination you can teach lambda calculus to
middle schoolers with the first half of this book.
Recommended implementation: Any. It uses the bare minimum primitives
of Scheme and builds up on them.
-
The Seasoned Schemer (1995)
The sequel to The Little Schemer. It introduces several advanced
concepts and delves deeper into functional programming
algorithms.
Difficulty: Intermediate. It helps reading TLS first.
Recommended implementation: Any. It builds upon the language built in
the previous book.
-
The Little Typer (2018)
Continuing from the previous little books, this book explores type
systems including dependent types.
Difficulty: Intermediate. Again, it helps reading TLS
first. You do not need prior understanding of static typing.
Recommended implementation: Racket's #lang pie.
-
The Reasoned Schemer (2018)
This book goes into the domain of logic programming
(relational programming in particular).
Difficulty: Intermediate. Same as above. You do not need
to know anything about logic programming to read this.
Recommended implementation: Any implementation of
miniKanren.
-
The Little Prover (2015)
This book teaches the principles of computational theorem proving
and writing provably correct programs.
Difficulty: Intermediate. Same as above. You do not need
to know anything about theorem proving beforehand.
Recommended implementation: Preferably Racket's
#lang dracula in DrRacket but you can use any Scheme
with the ACL2 shims provided with the book.
-
The Little Learner:
A Straight Line to Deep Learning (2023)
This book deep learning from the ground up and teaches its
practical uses.
Difficulty: Intermediate. Same as above. You do not need
to know anything about computational intelligence beforehand.
Recommended implementation: Racket, using the Malt library.
-
Beautiful Racket (2019)
An excellent book on language–oriented programming, made up of two
parts. The first part "Tutorials" is a collection of well–annotated
recipes that underline principles of high–level DSL design. The second
part "Explainers" revisits Racket's semantics and features.
Difficulty: Moderate. You're expected to know at least a bit
of Racket, although "Explainers" will serve as a refresher.
Recommended implementation: Racket.
-
Software Design for Flexibility:
How to Avoid Programming Yourself into a Corner (2021)
(Available for free through Open Access.)
Recommended implementation: MIT/GNU Scheme.
-
Don't Teach Coding: Until You Read This Book (2020)
A pedagogic book on teaching programming to pupils, mainly aimed at K–12 teachers.
Recommended implementation: Racket.
-
Animated Problem Solving (2022)
Recommended implementation: Racket.
-
Concrete Abstractions:
An Introduction to Computer Science Using Scheme (1997)
Recommended implementation: Any R4RS conformant Scheme.
-
Logic Programming in Scheme (2012)
Recommended implementation: Any R5RS conformant Scheme.
-
Language–Oriented Programming in Racket:
A Cultural Anthropology (2018)
Theory
Programming language theory books that build upon Scheme:
-
PLAI
— Programming Languages: Application and Interpretation (2007)
Recommended implementation: Racket's #lang plai.
-
EoPL
— Essentials of Programming Languages (2008)
Recommended implementation: Racket's #lang eopl.
-
SEwPR
— Semantics Engineering with PLT Redex (2009)
Recommended implementation: Racket.
-
Essentials of Compilation:
An Incremental Approach in Racket (2023)
Recommended implementation: Racket.
Implementing
Scheme implementation guides:
Other
-
SICM
— Structure and Interpretation of Classical Mechanics (2015)
A mechanics textbook in the style of SICP. The significance of this
book for Scheme programmers is that it is accompanied by
scmutils,
a full–blown linear algebra and numerical analysis library written in
MIT/GNU Scheme.
(Available for free through Open Access.)
Recommended implementation: MIT/GNU Scheme.
-
FDG
— Functional Differential Geometry (2013)
A mathematics textbook that teaches differential geometry
from a physics perspective, using Scheme in tandem with
classical mathematical notation.
(Available for free through Open Access.)
Recommended implementation: MIT/GNU Scheme.
Standards & Specifications
R5RS was the last commonly agreed–upon standard before the Grand
Schism, although it is considered to be woefully inadequate today.
The previous standards are only of historic interest nowadays.
R6RS and R7RS are the contemporary standards that continue to
coexist. R7RS comes in "small" (R5RS–like) and "large" (R6RS–like)
versions, although at the time of writing (2020), only the small version
has been finalised.
-
R0RS (1975)
— Scheme: An Interpreter for Extended Lambda Calculus
-
R1RS (1978)
— The Revised Report on Scheme, A Dialect of Lisp
-
R2RS (1985)
— The Revised Revised Report on Scheme, or An UnCommon Lisp
-
R3RS (1986)
— Revised3 Report on Algorithmic Language Scheme
-
IEEE/ANSI 1178 (1990)
— IEEE Standard for the Scheme Programming Language
-
R4RS (1991)
— Revised4 Report on Algorithmic Language Scheme
-
R5RS (1998)
— Revised5 Report on Algorithmic Language Scheme
-
ERR5RS (2007)
— Emergency Revision of Revised5 Report on Algorithmic Language Scheme (archived)
-
R6RS (2007)
— Revised6 Report on Algorithmic Language Scheme
-
R7RS Small (2013)
— Revised7 Report on Algorithmic Language Scheme
-
R7RS Large (WIP)
— Revised7 Report on Algorithmic Language Scheme
-
-
Scheme Reports
— Standardisation Process
-
SRFI
— Scheme Requests for Implementation
Additional resources
Other repositories
Individual collections
Outdated collections
Implementation documentation
In alphabetical order;