CMU 15-445: Database Systems
15-445 is CMU's database systems course: storage, buffer pools, indexes, query execution and optimization, concurrency control, and recovery, built around implementing real components inside the BusTub teaching database in C++. Its public lectures and projects have made it the internet's default database-internals curriculum.
Fennie is independent and not affiliated with Carnegie Mellon University. This is an unofficial study guide.
What makes it hard
The projects are serious C++ systems programming: each builds inside a real codebase where your component must satisfy interfaces you didn't design, and concurrency bugs in the later projects don't reproduce on demand. Self-learners arrive in waves from the famous lectures and discover the projects assume systems maturity the videos don't supply.
What you'll cover
- • Storage and buffer pool management
- • B+Tree indexes
- • Query execution and join algorithms
- • Query optimization
- • Concurrency control and transactions
- • Logging and crash recovery
The 15-445 study guide
How to study for CMU 15-445, step by step.
- 1
Get C++-fluent before the first project, not during
BusTub is modern C++ in a real codebase, and language friction during a project deadline is self-inflicted. If your C++ is approximate, spend the early weeks making it concrete.
- 2
Read the project's surrounding code first
Each project lives inside interfaces and invariants you didn't write. An hour reading the headers and tests before coding beats three hours of misled implementation.
- 3
Trace each mechanism on paper before implementing
B+Tree splits, buffer eviction, two-phase locking: work small examples by hand until the algorithm is yours, then code it. Implementing from a half-understood description is the slowest path through every project.
- 4
Budget double for the concurrency projects
When transactions and latching arrive, bugs stop reproducing reliably and progress turns nonlinear. Start those projects the day they open and test with sanitizers from the first commit.
- 5
Self-learners: pair every lecture with its project work
The lectures are famous for a reason, but database internals compile into understanding only through BusTub. Schedule project milestones with real dates. The abandoned-fork statistics are a warning, not trivia.
Today
Today's 15-445 plan
What a Fennie Daily Plan looks like for 15-445. 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-445 hard?
The projects are the difficulty: real C++ components inside a real codebase, with later projects adding concurrency bugs that resist reproduction. Conceptually it's well-taught and well-paced; students with solid systems footing who start projects early consistently succeed.
Can I take 15-445 online for free?
The lectures, notes, and BusTub projects are public, and the course has become the standard self-study path into database internals worldwide. No credit, full content. The projects, not the videos, are where the learning actually happens.
What should I know before 15-445?
Real C++ (not just C), data structures fluency, and systems basics at the 15-213 level. The buffer pool and recovery units assume you understand memory and caching natively. SQL familiarity helps but the course is about what's underneath SQL.
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.