Berkeley CS 162: Operating Systems and System Programming
CS 162 is Berkeley's operating systems course: processes and threads, scheduling, synchronization, virtual memory, file systems, and distributed-systems basics, with a semester-long group project sequence building pieces of the Pintos teaching OS in C. It's a core upper-division requirement for the CS major.
Fennie is independent and not affiliated with UC Berkeley. This is an unofficial study guide.
What makes it hard
162's workload reputation is the strongest in the major: the Pintos group projects are large, low-level C codebases where bugs are concurrency bugs, and group coordination is its own skill. Exams layer conceptual breadth (scheduling, paging, file systems) on top, so project crunch and exam prep compete all semester.
What you'll cover
- • Processes, threads, and concurrency
- • Synchronization primitives and deadlock
- • CPU scheduling
- • Virtual memory and paging
- • File systems
- • Sockets and distributed systems basics
The CS 162 study guide
How to study for Berkeley CS 162, step by step.
- 1
Choose your project group like it's a grade decision
It is one. The Pintos projects are team deliverables, and schedule-compatible, communicative teammates matter more than individually brilliant ones. Set a weekly working cadence in week one.
- 2
Read the Pintos codebase before writing to it
Each project phase starts faster if you've traced how the existing code paths work. Budget the first days for reading and diagramming, not coding; it pays back in fewer concurrency mysteries.
- 3
Learn synchronization by hand-simulating schedules
Race conditions and deadlocks make sense when you walk through thread interleavings on paper. That same skill is exactly what exam synchronization questions test.
- 4
Keep a running concept review alongside project work
The exams cover scheduling, paging, and file systems whether or not your project phase touched them recently. A small weekly review block prevents the classic 162 trap of arriving at midterms all-project, no-theory.
- 5
Work past exams for the design-question style
162 exams mix mechanical questions (page-table math, scheduling traces) with open design questions. Past exams calibrate both, and the mechanical genres are stable semester to semester.
Today's CS 162 plan
What a Fennie Daily Plan looks like for CS 162. Yours is built from your syllabus and adapts every day to your deadlines and progress.
- Review: Processes, threads, and concurrencyReview · 25 min
Work back through the CS 162 material on processes, threads, and concurrency. In the app, Fennie builds this from your own notes and syllabus.
- Practice: Synchronization primitives and deadlockPractice · 20 min
Targeted problems on synchronization primitives and deadlock, the kind CS 162 actually tests.
- Quick quiz: CPU schedulingQuiz · 10 min
Five generated questions to expose weak spots on cpu scheduling before the exam does.
- Preview: Virtual memory and pagingPreview · 10 min
A first pass over virtual memory and paging so the next session starts from familiar ground.
First plan free, no card required. Fennie is independent and unaffiliated with your school.
FAQ
Is CS 162 the hardest CS class at Berkeley?
It's routinely cited as the most time-consuming, mainly because of the Pintos group projects. The concepts are standard OS material; the difficulty is sustained workload plus group coordination inside a semester that also has real exams.
How much time does CS 162 take per week?
Expect 15-25 hours during project phases, with spikes near milestones. Group dynamics swing this widely; teams that establish a weekly working rhythm early consistently report saner semesters than teams that crunch.
What should I review before CS 162?
C fluency and memory-layout comfort from 61C are the real prerequisites, because Pintos is a C codebase where pointer bugs become concurrency mysteries. Reviewing caches and virtual-memory basics from 61C also gives the paging unit a head start.
More Berkeley courses
CS 61A: The Structure and Interpretation of Computer Programs
CS 61A is Berkeley's legendary intro CS course, taught primarily in Python with excursions into Scheme and SQL. It emphasizes abstraction (higher-order functions, recursion, object-oriented programming, and interpreters) and it's the first course in the CS 61 series that every CS and Data Science student takes.
CS 61B: Data Structures
CS 61B is Berkeley's data structures course, taught in Java, covering lists, trees, hashing, graphs, sorting, and asymptotic analysis. It's the second course in the 61 series and the one most cited in industry-interview prep. Its projects, including the famous build-your-own-world and Gitlet (build a mini Git), are substantial software engineering exercises.
CS 70: Discrete Mathematics and Probability Theory
CS 70 is Berkeley's discrete math and probability course, required for the CS major, covering proofs, graph theory, modular arithmetic, RSA, polynomials, counting, and a substantial probability unit. It's the theory gateway and, by reputation, the hardest lower-division course in the major.
CS 61C: Great Ideas of Computer Architecture (Machine Structures)
CS 61C completes Berkeley's 61 series, going below the abstraction line: C programming, RISC-V assembly, CPU datapaths and pipelining, caches, virtual memory, and parallelism. It's required for the CS and EECS majors and is the course where software students finally see what the hardware is doing.