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.
Build my CS 162 study planWhat 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.
- 6
Let Fennie referee projects versus exams
Upload the CS 162 schedule and Fennie's Daily Plans balance Pintos milestones against continuous exam review — exactly the collision this course creates — with paging and scheduling quizzes generated from your actual course materials. Free to start, and the code stays your team's.
Start my CS 162 plan free
How Fennie helps with CS 162
Fennie's Daily Plans are built for the CS 162 collision: Pintos group milestones and exam-heavy theory competing for the same weeks, balanced by scheduling both continuously. Chat through thread interleavings and page-table mechanics until you can simulate them on paper, and quiz on the mechanical exam genres while the project eats your coding hours.
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 — 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.
Pass CS 162 with a plan, not a cram
Upload your CS 162 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 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.