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.
What 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.
Today
Today's 15-210 plan
What a Fennie Daily Plan looks like for 15-210. 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 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.
More CMU courses
15-112: Fundamentals of Programming and Computer Science
15-112 is CMU's famous accelerated 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, covering Python programming plus computing concepts like data representation, algorithms, and the limits of computation. It's designed for students who aren't CS majors or who want a runway before 15-112, and 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. It covers data structures from stacks and queues through hash tables, trees, and graphs, and 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. It runs alongside 15-122 in the CMU CS core, and for most students it's the first time programming and proof become the same activity.