Berkeley 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.
Fennie is independent and not affiliated with UC Berkeley. This is an unofficial study guide.
What makes it hard
61A moves fast and assumes you can absorb abstraction quickly: recursion and higher-order functions arrive in the first weeks, and the exams are famous for environment diagrams and what-would-Python-print questions that punish shallow understanding. Students without prior programming experience often describe the pace as relentless.
What you'll cover
- • Higher-order functions and abstraction
- • Recursion and tree recursion
- • Environment diagrams
- • Object-oriented programming
- • Scheme and interpreters
- • SQL basics
The CS 61A study guide
How to study for Berkeley CS 61A, step by step.
- 1
Start assignments the day they're released
CS 61A moves relentlessly, and the office hours queue near deadlines is its own ecosystem. Starting Hog, Cats, Ants, and the Scheme project early turns them from crises into coursework.
- 2
Draw environment diagrams by hand from week one
Environment diagrams are the signature 61A exam skill and the foundation for understanding higher-order functions and closures. Practice them on paper weekly, not just when an exam looms.
- 3
Make recursion physical
Trace tree-recursive calls by writing out the call tree until the pattern of leap-of-faith reasoning clicks. If you can't predict what a recursive function returns without running it, keep tracing.
- 4
Live in the past-exam archives
Berkeley's past-exam culture exists for a reason. Work old 61A exams on paper, predicting output and writing code under time pressure. Exam tracing is a distinct skill from finishing projects, and only past exams build it.
Today
Today's CS 61A plan
What a Fennie Daily Plan looks like for CS 61A. 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 CS 61A hard?
Yes, especially without prior programming experience. The course is less about syntax and more about abstraction, and recursion hits early. It's very passable with consistent weekly effort, but students who fall two weeks behind rarely catch up comfortably.
Can I take CS 61A with no programming experience?
You can (it officially assumes none), but Berkeley offers CS 10 as a gentler on-ramp, and many students without experience take it first. If you go straight into 61A, commit to starting assignments the day they're released.
How do I study for CS 61A exams?
Past exams are everything. Work them on paper, drawing environment diagrams by hand and predicting output without running code. The exams test tracing and writing code under time pressure, which is a distinct skill from finishing the projects.
More Berkeley courses
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.
CS 161: Computer Security
CS 161 is Berkeley's upper-division security course, covering memory-safety attacks and defenses, cryptography, web security, and network security. Its centerpiece is a substantial project sequence, including a famous secure file-sharing system built in Go that students design and defend themselves.