Goal
Build a foundation in how computation works and how to reason about programs — not just write them. This path focuses on ideas that do not go out of date: abstraction, recursion, algorithmic thinking, and the mathematics behind computation.
Who this is for
Self-taught developers or bootcamp graduates who can build software but feel gaps in the underlying theory. Also useful for engineers who studied CS but want to revisit the fundamentals with more experience behind them.
Prerequisites
- Comfortable writing code in at least one language
- Basic familiarity with functions, loops, and recursion
- No prior CS theory required, but intellectual patience is necessary — both books are demanding
Reading order
1. Structure and Interpretation of Computer Programs — Abelson & Sussman
Start here. SICP teaches you to think about programs as data, functions as values, and abstraction as the central tool of programming. Reading it will feel slow. That is correct.
Use MIT Scheme or Racket. Do not substitute Python or JavaScript — the language choice is intentional and the exercises depend on it.
Work through Chapter 1–3 before deciding whether to continue. Chapter 4, where you build an interpreter, is the payoff of the first three chapters. Chapter 5 (register machines) can be skipped on a first read without losing the core ideas.
Do the exercises. The exercises are not optional review — they are the book.
2. The Algorithm Design Manual — Steven Skiena
Read after SICP. By this point, you can think about programs abstractly. This book teaches you to recognize problem types and map them to known solutions.
Part 1 (Chapters 1–12) builds algorithm design intuition through real problems and war stories. Work through it sequentially.
Part 2 is a catalog of problem types mapped to algorithms. Do not read it linearly — use it as a reference. When you encounter a new problem, look it up here before writing code.
Solve problems on LeetCode or Codeforces alongside Part 1. Pick problems that match whatever chapter you just finished.
Optional books
- Introduction to Algorithms (CLRS) by Cormen, Leiserson, Rivest, Stein — more rigorous and mathematically complete than Skiena. Read if you want proofs and formal analysis. Not a replacement — a complement.
- Mathematics for Computer Science by Lehman, Leighton, Meyer — free MIT OCW text covering logic, proofs, induction, probability, and graph theory. Read alongside or after SICP if the mathematical reasoning feels unfamiliar.
Practice ideas
- SICP: Do at least the unstarred exercises in each chapter. The starred exercises are optional but worth attempting.
- Algorithm Design Manual: After Part 1, pick 2–3 problems per chapter from a competitive programming site and solve them without looking at solutions first.
- After finishing both: implement a small interpreter for a tiny language (a calculator with variables and functions). SICP Chapter 4 gives you the model — implement it in a language you know well.
Expected outcome
After completing this path, you should be able to:
- Read and reason about unfamiliar code in terms of abstraction and data flow rather than just syntax
- Recognize algorithm problem types (search, graph, dynamic programming) without being told the category
- Estimate the time and space complexity of a program before running it
- Read and follow a mathematical proof well enough to evaluate technical arguments
- Understand what a compiler or interpreter is doing at a conceptual level