Harvard CS 121: Introduction to Theoretical Computer Science
CS 121 is Harvard's theory of computation course — computational models, Turing machines, uncomputability, and NP-completeness — taught from a free online textbook written for the course. It's the theory pillar of the CS concentration alongside CS 124.
Fennie is independent and not affiliated with Harvard University. This is an unofficial study guide.
Build my CS 121 study planWhat makes it hard
The course trades code for proofs about all possible code, and that jump in abstraction is the wall: students must argue about every program that could exist, not trace one that does. Reductions — both for uncomputability and NP-hardness — are the make-or-break skill, and they resist cramming completely.
What you'll cover
- • Computational models and Boolean circuits
- • Finite automata and regular expressions
- • Turing machines and equivalence of models
- • Uncomputability and the halting problem
- • Time complexity and P vs NP
- • NP-completeness and reductions
The CS 121 study guide
How to study for Harvard CS 121, step by step.
- 1
Read the textbook before lecture, not after
CS 121's free course textbook is precise where lectures are fast. Reading the chapter first turns lecture into a second pass — the right order for material this abstract.
- 2
Treat definitions as the exam content
Most lost points trace to using a definition loosely — what exactly is a reduction, what does it mean for a function to be computable. Restate each week's definitions from memory and build one example and one non-example.
- 3
Practice reductions as a genre
Uncomputability and NP-hardness proofs follow recognizable shapes. Collect every reduction from lecture and psets, name its shape, and rewrite two or three from memory before each exam.
- 4
Verbalize proofs before writing them
Explain the proof idea out loud in three sentences before formalizing. If the idea can't survive plain English, the formal version will wander — and graders notice wandering.
- 5
Keep the abstraction climbing with Fennie
Upload the CS 121 syllabus and Fennie's Daily Plan paces textbook chapters ahead of lecture and spaces reduction practice across the term, with definition-checking quizzes generated from the actual course materials. Free to start.
Start my CS 121 plan free
How Fennie helps with CS 121
Fennie's Daily Plans put CS 121's textbook reading ahead of lecture and keep reduction practice spaced across the term — the only way the proof shapes become recognizable. Chat through why a reduction runs in the direction it does, and drill the definitions that exam points quietly hinge on.
FAQ
Is CS 121 hard?
It's a major abstraction jump — proofs about all possible programs rather than code you can run. Students comfortable with discrete math adapt in a few weeks; reductions remain the hard part for everyone.
Do I need CS 121 for the Harvard CS concentration?
CS 121 is the standard theory-of-computation requirement for CS concentrators, typically taken after the intro sequence and discrete math preparation. Check current requirements for your track.
What should I know before CS 121?
Comfort with proofs and discrete math — induction, sets, and basic combinatorics. Programming experience helps intuition but the graded work is mathematical argument.
Pass CS 121 with a plan, not a cram
Upload your CS 121 materials and Fennie generates a Daily Plan paced to your deadline — plus chat, flashcards, and quizzes built from the actual course content.
Get started freeMore Harvard courses
CS50 — Introduction to Computer Science
CS50 is Harvard's famous intro to computer science, taught by David Malan — and through CS50x on edX, almost certainly the most-taken and most-searched college course in the world. It moves from C through data structures, memory, and algorithms to Python, SQL, and web development, ending with a final project.
CS 51 — Abstraction and Design in Computation
CS 51 is the standard course after CS50 for Harvard CS concentrators, teaching functional programming in OCaml alongside design principles — abstraction, modularity, and multiple programming paradigms. It's where students go from making code work to making it well-designed.
CS 124 — Data Structures and Algorithms
CS 124 is Harvard's algorithms course — divide and conquer, greedy algorithms, dynamic programming, graph algorithms, hashing, and NP-completeness — combining rigorous analysis with programming assignments. It's a core theory requirement for CS concentrators and a known interview-prep powerhouse.
CS 61 — Systems Programming and Machine Organization
CS 61 is Harvard's systems programming course — C and C++, assembly, memory, caching, process control, and concurrency — and one of the two standard follow-ons to CS50 for CS concentrators. Its course site publishes lecture notes and problem sets publicly, so it also draws self-learners looking for a systems sequel to CS50.