CMU 15-210: Parallel and Sequential Data Structures and Algorithms
15-210 is CMU's algorithms-and-data-structures core course with a signature twist: everything is analyzed for parallelism from the start, using work and span in a functional framework. It builds on 15-150 and 15-122 and is the course where CMU's algorithm training diverges from every other school's.
Fennie is independent and not affiliated with Carnegie Mellon University. This is an unofficial study guide.
Build my 15-210 study planWhat makes it hard
Thinking in work and span simultaneously is new for everyone — standard Big-O instincts only cover half the analysis. The functional setting means algorithm design happens through reduction, scan, and divide-and-conquer rather than loops and mutation, and exams demand both correct designs and tight cost bounds argued from the language's cost semantics.
What you'll cover
- • Work and span analysis
- • Divide and conquer in parallel
- • Sequences, scans, and reductions
- • Balanced trees and augmentation
- • Graph algorithms in parallel
- • Randomized algorithms
The 15-210 study guide
How to study for CMU 15-210, step by step.
- 1
Keep 15-150's functional fluency hot
210 designs algorithms through higher-order functions, and rusty ML reading speed taxes everything. A week-one refresher on the functional toolkit pays off across every assignment.
- 2
Compute work and span for everything
Every algorithm you meet, analyze both — and notice where they diverge. The dual analysis is the course's central skill and the exams' most reliable question type.
- 3
Learn the primitive cost specs cold
The costs of map, reduce, scan, filter, and the tree operations are the vocabulary every analysis is written in. Memorize them precisely; deriving them mid-exam is time you don't have.
- 4
Design with the parallel patterns deliberately
Contraction, divide-and-conquer, scan-based tricks — 210 problems yield to a recognizable pattern set. For each homework problem, name which pattern you're applying and why before writing anything.
- 5
Re-derive homework solutions before exams
From a blank page, reproduce the design and its cost argument. Exams test production speed on new problems, and re-derivation is the closest rehearsal available.
- 6
Schedule the climb with Fennie
Upload your 15-210 syllabus and Fennie's Daily Plan paces pattern practice and cost-analysis reps to the homework and exam dates, with quizzes generated from the actual course materials. It's free to start.
Start my 15-210 plan free
How Fennie helps with 15-210
Fennie's Daily Plans pace 15-210's distinctive skill set — designing with parallel patterns and arguing work/span bounds — across the semester with practice synced to homework and exams. Chat through why a span bound holds or which pattern a problem wants, the production skills exams isolate.
FAQ
Is 15-210 hard?
It's a demanding core course with a learning curve nobody skips: analyzing work and span simultaneously in a functional framework is new even for strong students. Once the pattern vocabulary clicks — usually mid-semester — the problems become recognizable; before that, trust the reps.
How is 15-210 different from a normal algorithms course?
Most schools teach sequential algorithms with Big-O; 210 teaches algorithms as parallel-first objects analyzed by work (total operations) and span (critical path), in a functional setting. It's why CMU graduates reason about parallelism natively rather than as an afterthought.
What should I review before 15-210?
15-150's functional programming — higher-order functions, recursion, induction proofs — and 15-122's data structures. The course assumes both fluently and spends its budget on the parallel cost model, not on reteaching foundations.
Pass 15-210 with a plan, not a cram
Upload your 15-210 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 CMU courses
15-112 — Fundamentals of Programming and Computer Science
15-112 is CMU's famous fast-paced introduction to programming in Python — control flow, functions, data structures, recursion, OOP, and efficiency — ending in an open-ended term project. Its public course website and the related CMU CS Academy platform give it a search footprint far beyond Pittsburgh.
15-110 — Principles of Computing
15-110 is CMU's gentler introduction to computing — Python programming plus computing concepts like data representation, algorithms, and the limits of computation — designed for students who aren't CS majors or who want a runway before 15-112. It's one of the largest courses on campus.
15-122 — Principles of Imperative Computation
15-122 teaches imperative programming with correctness front and center — contracts, loop invariants, and reasoning about code in the C0 teaching language before transitioning to real C — covering data structures from stacks and queues through hash tables, trees, and graphs. It's the second course of the CMU CS core.
15-150 — Principles of Functional Programming
15-150 teaches functional programming in Standard ML — types, recursion and induction, higher-order functions, and reasoning about programs as mathematical objects — alongside 15-122 in the CMU CS core. For most students it's the first time programming and proof become the same activity.