STUDY NOTES
Computer science is a single connected structure of ideas, each one resting on the ones beneath it. Understood that way, a hard result can be rederived from first principles the moment you need it, rather than recalled on cue.
The same ideas recur across subjects: the cost analysis that decides which algorithm scales, the automaton that fixes what a regular expression can match, the cache that explains why one loop outruns another. A small set of ideas appears again and again at different levels of the same machine.
Rigor is what makes an idea portable. A claim you have only seen asserted you can only repeat; a claim you have watched derived you can bend, combine, and trust in a case nobody showed you. A proof is the part of a result you get to keep.
An algorithm comes with an argument for why it is correct, not just code that passes its tests; a bound comes with the derivation that forces it. The reasoning is what tells you when a result will still hold.
Intuition and rigor work together. An idea appears in a concrete case first — a table filling in, a search frontier fanning out, a flow saturating its bottleneck — and then takes its precise form in symbols. The picture shows what is true; the symbols show why.
Cost recurs through all of it. The gap between a linear pass and a quadratic one is invisible on ten items and decisive on ten million; learning to see that gap before writing code is much of what separates a program that works from one that scales.
Follow any abstraction far enough and it ends in something physical — a logic gate settling, a clock ticking, a cache miss going out to main memory. Knowing that bottom layer is what keeps the machine from surprising you.
None of this makes a hard subject easy. The aim is to make it legible — its parts and the reasons behind them laid out in plain view — because a subject whose structure you can see is one you can actually learn.
Subjects.
6 availableHow to solve problems efficiently — and prove that you have. From measuring cost and choosing the right data structure, through divide & conquer, graphs, greedy, and dynamic programming, to problems that are provably intractable.
Automata, formal languages, computability, and complexity — what can be computed, and how hard it is.
From logic gates to pipelines, caches, and memory hierarchies — how a machine actually runs your code.
Computational methods for physical systems — simulating cloth, hair, fluids, and structures in code.
The relational model, query languages, and what keeps data correct under concurrency and failure.
Neural networks, gradient descent, and how machines learn patterns too subtle to program by hand.
Learning to act from reward alone — agents that try, fail, and improve by trial and error, from bandits to AlphaZero.
The classical science of intelligent agents — search, logic, planning, probability, and decision-making, from the Russell & Norvig canon.
How machines read, represent, and generate human language — from regular expressions and n-grams to embeddings, transformers, and LLMs.