Harvard CS 121: Introduction to Theoretical Computer Science
CS 121 is Harvard's theory of computation course, covering 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.
What 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 a reduction is, what it means 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.
Today
Today's CS 121 plan
What a Fennie Daily Plan looks like for CS 121. Yours is built from your own syllabus and adapts every day to your deadlines and progress.
First plan free, no card required. Fennie is independent and unaffiliated with your school.
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.
More Harvard courses
CS50: Introduction to Computer Science
CS50 is Harvard's famous intro to computer science, taught by David Malan. Through CS50x on edX, it is 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, covering divide and conquer, greedy algorithms, dynamic programming, graph algorithms, hashing, and NP-completeness. It combines rigorous analysis with programming assignments, and 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, covering C and C++, assembly, memory, caching, process control, and concurrency. It's 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.