Learn to think in programs.

The course is about managing program complexity, not memorizing one language. Python is the main tool; Fall 2026 also introduces Gleam, SQL, and a TypeScript application project.

Fall 2026 projects: Hog, Cats (computer-aided typing), Ants vs. SomeBees, and 4Animator. A two-week software-application unit is new in Fall 2026. Follow the live collaboration and AI rules: the general syllabus prohibits AI tools from filling in or correcting assignment code; the AI-focused project has its own instructions.

How the quiz fits in

Most weeks, lab includes a 10-minute, one-problem computer quiz based on a slight variation of homework. Re-solve the relevant homework problem from a blank page after you finish it. Practice quizzes, when released, appear on PrairieLearn. The best five of eight count in Fall 2026.

For every topic, practice two moves: predict what code does, then write a small program that does something similar. Strong understanding means you can trace, explain, and construct.

Topic order and exam scope vary. The course calendar and staff announcements are authoritative. See the Fall 2026 calendar and syllabus.

These original examples model the kinds of reasoning CS 61A develops. Work each one on paper first. Open the answer only after you have a prediction and can explain your steps.

def make_adder(x):
    def add(y):
        return x + y
    return add

plus_three = make_adder(3)
print(plus_three(4))

def digit_sum(n):
    if n < 10:
        return n
    return digit_sum(n // 10) + n % 10

print(digit_sum(527))

a = [1, 2]
b = a
a.append(3)
a = [0]
print(a)
print(b)

def count_leaves(tree):
    branches = tree[1:]
    if not branches:
        return 1
    return sum(count_leaves(branch) for branch in branches)

def steps():
    print("start")
    yield 2
    print("middle")
    yield 5

g = steps()
print("A", next(g))
print("B", next(g))

start
A 2
middle
B 5

For more practice, use the current course's past exams and topic-sorted questions. Always follow your semester's exam scope.

The official course study guide recommends starting early, spreading study over multiple days, solving problems actively, and reflecting on your reasoning. Use past exams after you understand the basics.

High-value drills

• Tracing / WWPD: write each evaluation step; draw environment diagrams for nested calls.
• Recursion: specify the smaller subproblem and base case before coding; test boundary inputs.
• Mutation: diagram references before and after each operation.
• Trees and linked lists: trace branches and pointers explicitly.
• Generators: track the suspended state and each yielded value.
• Code writing: outline the plan in plain language, implement it, then test tiny inputs.

Assume the final is cumulative until staff posts a narrower scope. Start by repairing weak spots from all midterms, then alternate old and newer topics so you can switch problem-solving modes.

• Use topic-sorted exam problems to target gaps; return to a mixed timed set to practice switching topics.
• Explain solutions out loud or to a study partner. If you cannot explain the approach, repeat the problem without notes.
• Use at least one timed practice set to find pacing issues before exam day.
• Exam recovery can raise midterm percentages based on the final, but it is a safety net, not a study strategy.

Projects are not side activities. They account for a third of the Fall 2026 points and make you combine ideas into programs larger than a single exam question. The syllabus describes projects as larger assignments that combine course ideas in interesting ways.

How the work is organized: Within a project, questions are grouped into phases that usually build on earlier functions. Follow that order, make a small piece work before adding the next one, and treat checkpoints as real milestones rather than last-minute submissions. The semester calendar also places the projects after the relevant concepts have begun appearing in lecture, lab, discussion, and homework.

Make each project teach you something

1. Read for the model first. Describe the program's pieces and how they interact before writing code.
2. Plan the phases. Mark dependencies, checkpoint requirements, tests, and your own work sessions.
3. Implement incrementally. Finish one requirement at a time; use the provided tests, then manually trace a small example.
4. Explain the result. For every function, say what it assumes, what it changes or returns, and why it works. Project interviews/checkoffs in some offerings make this understanding especially useful.
5. Keep a recovery buffer. Debugging and integration take time. Avoid scheduling all project work on the due date.

Pair programming is encouraged where allowed; alternate roles and ensure both partners can explain the whole result. Follow the current semester's collaboration and AI policy. Fall 2026 requires Provenance logs and restricts AI on the standard projects; the final AI-assisted project has specific, separate instructions, so follow its live spec.

Reddit is self-selected and mixes semesters. Treat it as lived experience, not a guarantee about difficulty, grading, or course policy.

• Read the current syllabus; confirm scope and deadlines.
• Set up course tools and know where assignments are submitted.
• Watch assigned videos and read before lecture.
• Start homework and project checkpoints early.
• Redo quiz-relevant homework problems without notes.
• Practice tracing and writing code every week.
• Use office hours while a question is still small.
• Diagnose missed exam problems and redo them from scratch.
• Leave time for timed practice before each exam.
• Protect sleep during exam week.

This guide references the Fall 2026 public course offering. The official syllabus, calendar, resources, and studying guide are primary sources. Reddit links are student perspectives only. HKN's public course guide is a useful overview but was last edited in 2020, so live course information takes precedence.