Learning Resources
This module is populated from the local chunked books in library/raw/semester-04-systems-programming/books, plus a small set of validated external references for the interpreter work. Use this page as a source map, not as an instruction to read everything.
Source Stack
| Book | Role | How to use it in this module |
|---|---|---|
| Structure and Interpretation of Computer Programs (Abelson, Sussman, Sussman) | Primary teaching source | The spine of every cluster; every primary concept points to specific SICP sections |
| The C Programming Language (Kernighan & Ritchie) | Contrast | When you want to see what "no closures, no first-class procedures" looks like, and why abstractions in C are awkward |
| Computer Organization and Design (Patterson & Hennessy) | Contrast, one cluster | Where interpretation bottoms out in machines, relevant to Concept 12 |
| CODE (Petzold) | Cross-reference | Motivational context; occasional cross-lookup for "what is running underneath" |
External Resources (validated)
All links below were fetched and verified on 2026-04-22.
| Source | What you get | Best use |
|---|---|---|
| MIT Press -- SICP Online (full text) | The canonical SICP text on the MIT Press companion site | When you want the authoritative version of a passage; cite this over unofficial mirrors |
| Sarabander's HTML SICP | A very readable HTML rendering of SICP 2e | When MIT's rendering is hard to read on your screen |
| Peter Norvig -- "(How to Write a (Lisp) Interpreter (in Python))" | A ~117-line Python Lisp interpreter with commentary | Primary external reference for Cluster 4; the gold standard of "minimal eval/apply" |
| Peter Norvig -- "(An ((Even Better) Lisp) Interpreter (in Python))" | Extends lispy with tail calls, macros, call/cc | When you are ready to extend Concept 11's evaluator |
| Bob Nystrom -- Crafting Interpreters | A full book that walks through a tree-walking interpreter (Java) and a bytecode VM (C) | Primary external for Concept 12; read "A Tree-Walk Interpreter" first, "A Bytecode Virtual Machine" later |
| Crafting Interpreters -- Tree-Walk Interpreter | Part II of the book, chapter list | Direct entry point for the interpreter clinic |
| Crafting Interpreters -- Bytecode VM | Part III, for staging and compilation | Concept 12 supporting reading |
| SICM (Structure and Interpretation of Classical Mechanics) | The Sussman/Wisdom physics book that uses SICP's functional style for mechanics | Optional; useful if you want to see the same functional-abstraction habits applied outside CS |
| MIT OCW 6.001 -- Structure and Interpretation of Computer Programs | Lecture videos and problem sets from the original SICP course | If you want the Abelson/Sussman lectures directly |
Resource Map by Cluster
Cluster 1: Abstraction as the Engineering Move
| Need | Best local chunk | Why |
|---|---|---|
| procedures as black boxes | SICP 1.1.8 Procedures as black-box abstractions | Canonical statement of procedural abstraction |
| compound procedures | SICP 1.1.4 Compound procedures | Introduces define and the call model |
| data abstraction foundations | SICP 2.1 Introduction to data abstraction | The rational-number example in full |
| abstraction barriers | SICP 2.1.2 Abstraction barriers | Direct statement of the barrier idea |
| layered design | SICP 2.1.2 Abstraction barriers (part 2) | Layered design with rationals |
| multiple representations | SICP 2.4 Multiple representations for abstract data | Complex numbers in polar + rectangular |
| C-level contrast | K&R: Basics of functions | What "procedure" means in C |
| C structs | K&R: Basics of structures | Data abstraction without language support |
Cluster 2: Higher-Order Procedures and Closures
| Need | Best local chunk | Why |
|---|---|---|
| formulating abstractions | SICP 1.3 Formulating abstractions with higher-order procedures | The canonical case for HOFs |
| passing procedures | SICP 1.3.1 Procedures as arguments | sum, integral worked out |
| lambda | SICP 1.3.2 Constructing procedures using lambda | Explicit lambda introduction |
| returning procedures | SICP 1.3.4 Procedures as returned values | average-damp, deriv, newton |
| map/filter/reduce | SICP 2.2.3 Sequences as conventional interfaces | The canonical treatment |
| C contrast | K&R: Pointers to functions | Function pointers as poor-man's HOFs |
Cluster 3: Evaluation Models
| Need | Best local chunk | Why |
|---|---|---|
| substitution model | SICP 1.1.5 The substitution model | Includes applicative vs normal order |
| iterative vs recursive processes | SICP 1.2 Procedures and processes | Where tail recursion is first motivated |
| environment model | SICP 3.2 The environment model of evaluation | The model that explains closures |
| evaluation rules | SICP 3.2.1 The rules for evaluation | Precise procedure-application rules |
| frames as state | SICP 3.2.3 Frames as the repository of local state | Where captured state actually lives |
| lazy evaluation | SICP 4.2 Variations on a Scheme -- lazy evaluation | Normal-order as a language choice |
| tail recursion in the evaluator | SICP 5.4.2 Sequence evaluation and tail recursion | What TCO costs in an implementation |
Cluster 4: Metacircular and Interpreter Design
| Need | Best local chunk | Why |
|---|---|---|
| metacircular evaluator intro | SICP 4.1 The metacircular evaluator | The chapter opener |
| eval/apply core | SICP 4.1.1 The core of the evaluator | Concept 10's code sample is derived from here |
| syntax representation | SICP 4.1.2 Representing expressions | How to ask "is this an if?" in Scheme |
| runtime data | SICP 4.1.3 Evaluator data structures | Environments, procedure values |
| running the evaluator | SICP 4.1.4 Running the evaluator as a program | REPL wiring, primitives |
| analysis separation | SICP 4.1.7 Separating syntactic analysis from execution | Basis for Concept 12's staging |
| compilation | SICP 5.5 Compilation | SICP's compiler chapter |
| compiler structure | SICP 5.5.1 Structure of the compiler | Direct map to Concept 12 |
Cluster 5: State, Mutation, and Language Design
| Need | Best local chunk | Why |
|---|---|---|
| introducing assignment | SICP 3.1 Assignment and local state | The chapter that reframes the language |
| local state | SICP 3.1.1 Local state variables | Bank-account example |
| benefits of assignment | SICP 3.1.2 The benefits of introducing assignment | What we gain |
| costs of assignment | SICP 3.1.3 The costs of introducing assignment | What we lose |
| streams intro | SICP 3.5 Streams | Chapter intro |
| delayed lists | SICP 3.5.1 Streams are delayed lists | cons-stream, delay, force |
| infinite streams | SICP 3.5.2 Infinite streams | Primes, Fibonacci |
| streams + delayed eval | SICP 3.5.4 Streams and delayed evaluation | Rigorous treatment |
| concurrency overview | SICP 3.4 Concurrency: time is of the essence | Chapter intro |
| nature of time | SICP 3.4.1 The nature of time in concurrent systems | Ordering, races |
| serializers / mutexes | SICP 3.4.2 Mechanisms for controlling concurrency | Mutual exclusion |
Primary Concept -> Book Chunk Map
Every primary concept maps to at least one book chunk:
Use Rules
- If you are stuck on abstraction, open SICP §2.1 first -- the rational-number example is the highest-leverage passage in the book.
- If you are stuck on closures, re-read SICP §1.3.4 and §3.2.3 together; they belong as a pair.
- If you are stuck on the interpreter, work through Norvig's lispy line by line; then return to Concept 11 and re-type it from memory.
- If you are stuck on mutation/concurrency, SICP §3.1 motivates the cost and §3.4 motivates the abstractions.
- Open one chunk for one concept gap; do not read a whole chapter by default.
- If re-reading is not fixing the problem, stop reading and implement the Mini Drill or the matching kata. Interpreter-level concepts in particular yield much faster to writing than to reading.