What actually shows up on the first midterm
I took CS61A at Berkeley back in 2023, survived the midterm, and tutored a few juniors after. The exam isn't hard if you know what they test. It's hard when you study the wrong stuff. Most people waste weeks on recursion patterns that never appear. The real scope is shorter than you think. Project 0 through Project 2ish, roughly. Tables, lambdas, mutations, some basic OOP with objects and classes. They love asking you to trace function calls with side effects. If you can draw a frame diagram without sweating, you're already ahead of half the class.
Where to find a Cs61a Midterm 1 Study Guide
There's no official one from the course staff. What exists are scattered PDFs on GitHub, some Google Docs that seniors updated in bad faith, and the archived midterms from previous semesters. Start with the archived versions. They show you exactly how badly questions can be worded. The best resource I found was a shared Google Doc called "CS61A Midterm Prep" that someone made in fall 2022. It had actual exam questions with handwritten solutions. Copy it before the link dies. These things get nuked every semester when ownership changes. After that, go to the textbook website. Section on mutation and reference semantics is where most students lose points. Not because the concept is hard. Because they don't realize how often the exam will ask "what does this print" with nested lists.
The stuff everyone gets wrong
Mutation. Specifically, in-place operations versus reassignment. Students confuse = on a list with methods like .append(). One shows up in frame diagrams. The other doesn't create a new binding. I failed a practice problem once because I didn't draw the arrow from the variable to the mutated list. The workaround was simple. For every function call, I drew two boxes. One for the parameter name. One for the value it pointed to. When mutation happened, I updated the value box. When reassignment happened, I drew a new arrow. Takes twenty minutes extra. Cuts your error rate from 40% to maybe 10%. Lambdas are another trap. Not because they're complex. Because the exam will wrap them in map() or filter() and ask you to write the equivalent using regular functions. Or vice versa. I once spent twelve minutes converting a lambda to a def when the question just wanted the output.
Get the Full Details
What actually matters for the test
High information density over breadth. The exam tests depth in three areas. Tracing with mutation. Understanding what functions return. Knowing the difference between shallow and deep copies when lists get nested. Everything else is bonus points at best. I spent way too much time on SQL and higher-order functions. The midterm barely touches them. Maybe one question. But I lost an entire week practicing joins when the real test just wanted you to understand frame diagrams with mutable default arguments. The counter-intuitive insight nobody shares is this. The hardest questions on CS61A midterm 1 aren't the ones with the most code. They're the ones with three lines that mutate a list inside a nested function call. If you can trace f(g([1,2])) where both functions append to their input, you'll pass. Don't overthink it.
How I actually studied
Two weeks before the exam. First, I did the textbook exercises on mutation. Not all of them. Just the ones with frame diagrams. Then I took the archived midterms from 2019 through 2022. Time limit myself. No notes. Treat it like the real thing. After each practice test, I spent more time reviewing my mistakes than taking the test. Specifically, I wrote down why I got each wrong answer. Not just the right answer. The reasoning gap. This usually cuts the process down from studying for hours to about forty-five minutes per topic. One thing I regret not doing earlier. Practicing drawing frame diagrams with mutable default arguments. The exam asked about a function with def f(x=[]): and I froze for three minutes. Now I always check for default arguments first when tracing. Takes five seconds extra. Prevents entire categories of errors.
When this approach fails
If your professor changes the scope mid-semester. I know someone whose midterm added recursion out of nowhere. The study guide covered zero recursion. In that case, fall back to the textbook's end-of-chapter problems. They're more reliable than any student-made guide. Also, this won't help if you haven't done the projects. The exam assumes you've written code with lists and functions. Not just read about them. I tutored a student once who had never submitted a single project. Studying for three weeks straight. Still failed. You need muscle memory from actually coding. The bottom line. CS61A midterm 1 is manageable if you study the right stuff. Start with mutation tracing. Do archived exams. Understand frame diagrams. Don't waste time on recursion or SQL unless your professor explicitly says it's on the test. That's it.
