Structure and Interpretation of Computer Programs - JavaScript Edition

Start with the smallest pieces of a language: expression, value, name, environment, function, predicate, and conditional choice. Newton's square-root method becomes the first real example of a process hidden behind a clean function boundary.

Separate the function's mathematical definition from the process it generates. Factorial, Fibonacci, exponentiation, Euclid's algorithm, and primality testing show the difference between recursive shape, iterative state, tree explosion, and asymptotic cost.

Turn repeated control patterns into functions that accept functions. Summation, product, accumulation, fixed points, average damping, and returned functions show why JavaScript functions-as-values are not syntax sugar but an abstraction mechanism.

Data becomes a contract between constructors and selectors. Rational numbers and intervals teach the core barrier: clients should depend on what operations mean, not how pairs, numbers, or objects happen to represent them.

Pairs close over pairs, so data can become a tree. Lists, maps, filters, accumulators, nested structures, and the picture language show the same interface pattern over many shapes of data.

Programs can manipulate symbols as data. Differentiation turns algebra into tree rewriting, sets expose representation trade-offs, and Huffman trees make the cost model visible in the shape of the encoding tree.

One abstract object can have many useful representations. Complex numbers in rectangular and polar form motivate tags, operation tables, and the additive style where a new representation can be installed without rewriting old code.

Generic operations extend data-directed programming into a system. Coercion, type towers, and symbolic algebra show the central tension: add new types, add new operations, and keep the representation barriers intact.

Assignment gives objects identity across time. Bank accounts and monitored functions show what state buys, then immediately show the price: substitution is no longer enough because evaluation now depends on history.

The substitution model gives way to environments: frames, bindings, enclosing scopes, and function objects with remembered environments. This is the operational model that makes closures and local state precise.

Mutation moves from variables into data structure. Queues, tables, event-driven circuit simulation, and constraint propagation show how local mutation can power systems that model changing worlds.

Once multiple processes interleave, mutation becomes a coordination problem. Serializers, races, ordering, deadlock pressure, and protected operations expose why shared state and time are inseparable.

Streams recover modularity by separating what a sequence is from when its elements are computed. Infinite data, signal processing, numerical methods, and stream-based state all become ordinary sequence programs.

Build an evaluator for a JavaScript-like language in JavaScript. Evaluation, application, environments, primitive functions, compound functions, and the driver loop make the language's semantics executable.

After the evaluator works, split syntax analysis from execution so repeated evaluation does less work. This is the first step from interpreter-as-specification toward implementation strategy.

Change the evaluator and the language changes. Thunks, memoization, forcing, and delayed arguments make laziness a semantic choice rather than a library trick.

Make search part of the language. Choice points, backtracking, failure continuations, and constraint-style programs show how a new evaluator can expose a new programming model.

A query system turns facts and rules into a tiny logic language. Pattern matching, unification, stream-based search, rule application, and frames make declarative retrieval concrete.

Replace high-level functions with registers, operations, tests, branches, labels, and a stack. The lesson is not nostalgia for assembly; it is the cost model behind recursion and control.

Build the machine as a program. The simulator, assembler, instruction execution functions, tracing, and performance counters make the hardware model inspectable.

Memory stops looking infinite. Vectors, free lists, garbage collection, and the explicit-control evaluator show how environments, continuations, and function application become concrete machine state.

The capstone: compile high-level expressions into register-machine instructions. Instruction sequences, linkage, preserving registers, lexical addressing, and compiled/evaluated interop close the loop from language design to execution.