(Lispex)sicp.io
Original second edition · coverage map

Make the missing parts visible.

This map follows every numbered subsection in the original second-edition table of contents. Covered means a dedicated runnable Lispex lesson substantially addresses the subsection; partial means a relevant executable surface exists but does not yet cover the subsection as a whole.

Original subsections94
Covered50
Partial39
Addressed95%
CoveredPartialMissingvalidation deferred = authored route, validation sweep queued
Showing 94 of 94 subsectionsvalidation deferred = authored route, validation sweep queued
Chapter 1

Building Abstractions with Procedures

18 of 18 addressed · 12 coveredPartial 6 · Missing 018 / 18
1.1

The Elements of Programming

  1. 1.1.1

    Expressions

    Covered
    1.1 Expressions
  2. 1.1.2

    Naming and the Environment

    Partial
    1.1 Expressions1.2 Procedures

    Names and environments appear throughout, but there is no dedicated lesson on definition and lookup.

  3. 1.1.3

    Evaluating Combinations

    Covered
    1.1 Expressions
  4. 1.1.4

    Compound Procedures

    Covered
    1.2 Procedures
  5. 1.1.5

    The Substitution Model for Procedure Application

    Partial
    1.3 Process shapes

    Process shape is visible, but substitution is not reconstructed step by step.

  6. 1.1.6

    Conditional Expressions and Predicates

    Partial
    1.1 Expressions1.2 Procedures

    Conditionals and predicates are used as building blocks rather than isolated in one complete lesson.

  7. 1.1.7

    Example: Square Roots by Newton's Method

    Covered
    1.6 Iterative square roots
  8. 1.1.8

    Procedures as Black-Box Abstractions

    Partial
    1.2 Procedures1.4 Higher-order procedures

    Procedure boundaries are taught, but the complete black-box decomposition discussion is not yet mapped.

1.2

Procedures and the Processes They Generate

  1. 1.2.1

    Linear Recursion and Iteration

    Covered
    1.3 Process shapes
  2. 1.2.2

    Tree Recursion

    Covered
    1.11 Tree recursion and growthvalidation deferred
  3. 1.2.3

    Orders of Growth

    Covered
    1.11 Tree recursion and growthvalidation deferred
  4. 1.2.4

    Exponentiation

    Covered
    1.9 Fast exponentiation
  5. 1.2.5

    Greatest Common Divisors

    Covered
    1.5 Euclid's algorithm
  6. 1.2.6

    Example: Testing for Primality

    Partial
    1.10 Fast modular exponentiation

    The lesson implements expmod and fixed-base Fermat checks, not the full timed-prime and probabilistic-testing development.

1.3

Formulating Abstractions with Higher-Order Procedures

  1. 1.3.1

    Procedures as Arguments

    Covered
    1.4 Higher-order procedures
  2. 1.3.2

    Constructing Procedures Using Lambda

    Partial
    1.4 Higher-order procedures1.8 Fixed-point search

    Lambda expressions are used directly, but syntax, scope, and naming are not isolated as their own lesson.

  3. 1.3.3

    Procedures as General Methods

    Covered
    1.8 Fixed-point search1.7 Continued fractions1.6 Iterative square roots
  4. 1.3.4

    Procedures as Returned Values

    Covered
    1.12 Returned proceduresvalidation deferred
Chapter 2

Building Abstractions with Data

18 of 18 addressed · 13 coveredPartial 5 · Missing 018 / 18
2.1

Introduction to Data Abstraction

  1. 2.1.1

    Example: Arithmetic Operations for Rational Numbers

    Covered
    2.1 Data abstraction
  2. 2.1.2

    Abstraction Barriers

    Covered
    2.1 Data abstraction
  3. 2.1.3

    What Is Meant by Data?

    Partial
    2.1 Data abstraction

    Constructor-selector contracts are demonstrated, but procedural representations are not developed fully.

  4. 2.1.4

    Extended Exercise: Interval Arithmetic

    Covered
    2.8 Interval arithmetic
2.2

Hierarchical Data and the Closure Property

  1. 2.2.1

    Representing Sequences

    Covered
    2.2 Sequences
  2. 2.2.2

    Hierarchical Structures

    Covered
    2.3 Trees
  3. 2.2.3

    Sequences as Conventional Interfaces

    Covered
    2.5 Sequence pipelines
  4. 2.2.4

    Example: A Picture Language

    Covered
    2.14 Picture-language paintersvalidation deferred2.15 Picture-language compositionvalidation deferred
2.3

Symbolic Data

  1. 2.3.1

    Quotation

    Partial
    2.6 Symbolic differentiation2.10 Huffman code treesvalidation deferred

    Quoted data is used extensively, but quotation and equality are not isolated as a complete lesson.

  2. 2.3.2

    Example: Symbolic Differentiation

    Covered
    2.6 Symbolic differentiation
  3. 2.3.3

    Example: Representing Sets

    Partial
    2.9 Ordered-list sets

    Ordered-list membership and union are covered; unordered lists and tree-based sets remain unmapped.

  4. 2.3.4

    Example: Huffman Encoding Trees

    Covered
    2.10 Huffman code treesvalidation deferred
2.4

Multiple Representations for Abstract Data

  1. 2.4.1

    Representations for Complex Numbers

    Covered
    2.11 Complex-number representationsvalidation deferred
  2. 2.4.2

    Tagged data

    Covered
    2.7 Generic tagged operations
  3. 2.4.3

    Data-Directed Programming and Additivity

    Partial
    2.7 Generic tagged operations2.13 Symbolic algebravalidation deferred

    Operation tables and an additive polynomial package are executable, but a reusable installation protocol across a complete generic system is not.

2.5

Systems with Generic Operations

  1. 2.5.1

    Generic Arithmetic Operations

    Partial
    2.7 Generic tagged operations2.12 Mixed-type coercionvalidation deferred2.13 Symbolic algebravalidation deferred

    Generic dispatch, an explicit numeric tower, and polynomial add/multiply are executable; dropping, a broader arithmetic package set, and a complete tower remain unmapped.

  2. 2.5.2

    Combining Data of Different Types

    Covered
    2.12 Mixed-type coercionvalidation deferred
  3. 2.5.3

    Example: Symbolic Algebra

    Covered
    2.13 Symbolic algebravalidation deferred
Chapter 3

Modularity, Objects, and State

19 of 19 addressed · 10 coveredPartial 9 · Missing 019 / 19
3.1

Assignment and Local State

  1. 3.1.1

    Local State Variables

    Covered
    3.1 Local state
  2. 3.1.2

    The Benefits of Introducing Assignment

    Partial
    3.1 Local state3.6 Seeded pseudorandomness

    Stateful encapsulation and reproducibility are executable, but the section is not followed example for example.

  3. 3.1.3

    The Costs of Introducing Assignment

    Partial
    2.4 Shared identity3.9 Shared-state interleavings

    Aliasing and order dependence are visible, while the full environment-model comparison remains incomplete.

3.2

The Environment Model of Evaluation

  1. 3.2.1

    The Rules for Evaluation

    Partial
    3.2 Private environments4.2 Explicit environments

    Frames and lookup are executable, but the complete environment evaluator rules are not presented together.

  2. 3.2.2

    Applying Simple Procedures

    Partial
    3.2 Private environments1.2 Procedures

    Closure creation and private locations are covered without a full frame-by-frame application visualizer.

  3. 3.2.3

    Frames as the Repository of Local State

    Covered
    3.2 Private environments
  4. 3.2.4

    Internal Definitions

    Covered
    3.11 Internal definitionsvalidation deferred
3.3

Modeling with Mutable Data

  1. 3.3.1

    Mutable List Structure

    Partial
    2.4 Shared identity3.5 Mutable queues

    Pair mutation and aliases are visible, but cycles, destructive append, and complete mutable-list tooling are not mapped.

  2. 3.3.2

    Representing Queues

    Covered
    3.5 Mutable queues
  3. 3.3.3

    Representing Tables

    Covered
    3.12 Mutable tablesvalidation deferred
  4. 3.3.4

    A Simulator for Digital Circuits

    Partial
    3.8 Discrete-event agenda

    The ordered agenda and simulated time are covered, but wires, gates, and circuit propagation are not.

  5. 3.3.5

    Propagation of Constraints

    Covered
    3.7 Constraint propagation
3.4

Concurrency: Time Is of the Essence

  1. 3.4.1

    The Nature of Time in Concurrent Systems

    Covered
    3.9 Shared-state interleavings
  2. 3.4.2

    Mechanisms for Controlling Concurrency

    Partial
    3.10 Explicit serializersvalidation deferred

    A modeled serializer and test-and-set boundary are executable; real threads, fairness, and deadlock analysis are explicitly out of scope.

3.5

Streams

  1. 3.5.1

    Streams Are Delayed Lists

    Covered
    3.3 Memoized promises3.4 Streams
  2. 3.5.2

    Infinite Streams

    Covered
    3.4 Streams
  3. 3.5.3

    Exploiting the Stream Paradigm

    Partial
    3.4 Streams

    Finite demand on infinite streams is covered; the numerical stream applications are not yet mapped.

  4. 3.5.4

    Streams and Delayed Evaluation

    Covered
    3.3 Memoized promises3.4 Streams
  5. 3.5.5

    Modularity of Functional Programs and Modularity of Objects

    Partial
    3.1 Local state3.4 Streams

    Both models are present in separate lessons, but their full comparative case study is not.

Chapter 4

Metalinguistic Abstraction

17 of 17 addressed · 8 coveredPartial 9 · Missing 017 / 17
4.1

The Metacircular Evaluator

  1. 4.1.1

    The Core of the Evaluator

    Partial
    4.1 Expressions as data4.3 Special forms4.12 Internal-definition transformationvalidation deferred4.13 Running an evaluator programvalidation deferred

    Core dispatch, procedure-body preprocessing, and a finite eval/apply driver are executable, but they do not yet reproduce the complete evaluator development.

  2. 4.1.2

    Representing Expressions

    Covered
    4.1 Expressions as data4.5 Derived let syntax
  3. 4.1.3

    Evaluator Data Structures

    Partial
    4.2 Explicit environments4.6 Explicit thunks4.12 Internal-definition transformationvalidation deferred4.13 Running an evaluator programvalidation deferred

    Environments, compound-procedure records, mutable global bindings, represented thunks, and explicit unassigned locals are executable, but the complete evaluator data-structure set is not assembled.

  4. 4.1.4

    Running the Evaluator as a Program

    Covered
    4.13 Running an evaluator programvalidation deferred
  5. 4.1.5

    Data as Programs

    Partial
    4.1 Expressions as data4.5 Derived let syntax4.12 Internal-definition transformationvalidation deferred4.13 Running an evaluator programvalidation deferred

    Programs are transformed and executed as quoted data through derived let, internal-definition scan-out, and a finite top-level driver, but the complete discussion is not mapped.

  6. 4.1.6

    Internal Definitions

    Covered
    4.12 Internal-definition transformationvalidation deferred
  7. 4.1.7

    Separating Syntactic Analysis from Execution

    Covered
    4.4 Analyze then run
4.2

Variations on a Scheme -- Lazy Evaluation

  1. 4.2.1

    Normal Order and Applicative Order

    Partial
    4.6 Explicit thunks

    Demand and memoization are explicit, but evaluation-order examples are not developed fully.

  2. 4.2.2

    An Interpreter with Lazy Evaluation

    Partial
    4.6 Explicit thunks

    Explicit thunks model the core representation change, not a complete lazy interpreter.

  3. 4.2.3

    Streams as Lazy Lists

    Partial
    3.4 Streams4.6 Explicit thunks

    Streams and explicit thunks exist in separate layers; the lazy-list evaluator integration is missing.

4.3

Variations on a Scheme -- Nondeterministic Computing

  1. 4.3.1

    Amb and Search

    Covered
    4.7 Nondeterministic search4.14 Amb evaluatorvalidation deferred
  2. 4.3.2

    Examples of Nondeterministic Programs

    Partial
    4.7 Nondeterministic search4.14 Amb evaluatorvalidation deferred

    Finite alternatives, constraints, all-solution collection, and an explicit solution cap are executable, but the broader puzzle set and infinite-search policies are not.

  3. 4.3.3

    Implementing the Amb Evaluator

    Covered
    4.14 Amb evaluatorvalidation deferred
4.4

Logic Programming

  1. 4.4.1

    Deductive Information Retrieval

    Covered
    4.9 Finite rule queries
  2. 4.4.2

    How the Query System Works

    Partial
    4.9 Finite rule queries4.10 Bounded recursive rulesvalidation deferred

    Frames, rule expansion, and a visible frontier are covered in deliberately narrow evaluators.

  3. 4.4.3

    Is Logic Programming Mathematical Logic?

    Covered
    4.11 Logic programming limitsvalidation deferred
  4. 4.4.4

    Implementing the Query System

    Partial
    4.8 Pattern-directed matching4.9 Finite rule queries4.10 Bounded recursive rulesvalidation deferred

    Matching and bounded recursive rules are executable, but general unification, renaming, negation, and a complete query engine are not.

Chapter 5

Computing with Register Machines

17 of 22 addressed · 7 coveredPartial 10 · Missing 517 / 22
5.1

Designing Register Machines

  1. 5.1.1

    A Language for Describing Register Machines

    Partial
    5.2 Program-counter control5.8 Instruction label resolution5.9 Resolved controller execution

    Controller data and core instruction forms are present, but the complete machine-description language is not.

  2. 5.1.2

    Abstraction in Machine Design

    Partial
    5.1 Register state5.2 Program-counter control

    State and controller boundaries are explicit without the full sequence of machine redesigns.

  3. 5.1.3

    Subroutines

    Covered
    5.11 Machine subroutinesvalidation deferred
  4. 5.1.4

    Using a Stack to Implement Recursion

    Covered
    5.3 Explicit stack control
  5. 5.1.5

    Instruction Summary

    Partial
    5.9 Resolved controller execution

    The implemented executor supports a finite subset of assign, test, branch, goto, and halt.

5.2

A Register-Machine Simulator

  1. 5.2.1

    The Machine Model

    Covered
    5.1 Register state5.2 Program-counter control5.9 Resolved controller execution
  2. 5.2.2

    The Assembler

    Covered
    5.8 Instruction label resolution
  3. 5.2.3

    Generating Execution Procedures for Instructions

    Partial
    5.9 Resolved controller execution

    Instruction execution is interpreted by one finite executor rather than generated as a general simulator procedure set.

  4. 5.2.4

    Monitoring Machine Performance

    Covered
    5.10 Machine instrumentationvalidation deferred
5.3

Storage Allocation and Garbage Collection

  1. 5.3.1

    Memory as Vectors

    Partial
    5.7 Reachable heap objects

    Reachability is explicit, but car/cdr vector memory and free-pointer allocation are not implemented.

  2. 5.3.2

    Maintaining the Illusion of Infinite Memory

    Partial
    5.7 Reachable heap objects

    Tracing and unreachable classification are covered without copying collection or reclamation.

5.4

The Explicit-Control Evaluator

  1. 5.4.1

    The Core of the Explicit-Control Evaluator

    Missing

    No dedicated runnable Lispex lesson yet.

    No complete explicit-control evaluator controller is available yet.

  2. 5.4.2

    Sequence Evaluation and Tail Recursion

    Missing

    No dedicated runnable Lispex lesson yet.

    Tail-recursive sequence evaluation inside the explicit-control evaluator is not yet mapped.

  3. 5.4.3

    Conditionals, Assignments, and Definitions

    Missing

    No dedicated runnable Lispex lesson yet.

    These evaluator controller paths have no runnable machine lesson yet.

  4. 5.4.4

    Running the Evaluator

    Missing

    No dedicated runnable Lispex lesson yet.

    There is no end-to-end explicit-control evaluator run yet.

5.5

Compilation

  1. 5.5.1

    Structure of the Compiler

    Partial
    5.4 Compile and run5.5 Register preservation

    A small compiler and instruction-sequence contracts are present, not the full compiler architecture.

  2. 5.5.2

    Compiling Expressions

    Partial
    5.4 Compile and run

    Constants and arithmetic expression trees are compiled; variables, assignments, definitions, and conditionals are not complete.

  3. 5.5.3

    Compiling Combinations

    Partial
    5.4 Compile and run

    Stack arithmetic preserves operand order, but general procedure calls and linkage are not compiled.

  4. 5.5.4

    Combining Instruction Sequences

    Covered
    5.5 Register preservation
  5. 5.5.5

    An Example of Compiled Code

    Partial
    5.4 Compile and run

    Small arithmetic examples are emitted and executed; a full recursive compiled procedure is not shown.

  6. 5.5.6

    Lexical Addressing

    Covered
    5.6 Lexical addresses
  7. 5.5.7

    Interfacing Compiled Code to the Evaluator

    Missing

    No dedicated runnable Lispex lesson yet.

    Compiled procedures and the evaluator do not yet share one callable runtime boundary.

How to read this map. Coverage is an editorial product-status judgment, not a proof that a lesson reproduces every paragraph, exercise, or semantic claim in the book. A deferred badge means the route is authored and wired but remains queued for the owner-requested packaged-Wasm, trace, build, and browser validation sweep.