AP CSA Core & Exam Preparation
The bridge from knowing Java to solving AP CSA problems: tracing mastery, specification-driven implementation, the four FRQ types, MCQ strategy and error clinics, timed practice, and a full exam simulation — aligned to the revised (Fall 2025) AP CSA framework.
Who this course is for
Students who finished AP CSA Foundations (or know core Java) and want exam performance: reliable AP-style problem solving, code tracing under pressure, FRQ methodology, and timed practice before moving to full mock exams.
What you will be able to do
- Trace unfamiliar Java programs with state tables, frames, and dispatch reasoning
- Implement methods and classes directly from specifications, honoring preconditions and edge cases
- Solve the exam's four FRQ types with the eight-step workflow and partial-credit strategy
- Apply MCQ strategy: prediction-first answering, trap recognition, and probe-based elimination
- Master arrays, ArrayList, 2D arrays, strings, inheritance, and recursion at AP problem depth
- Debug broken solutions by locating the first contract divergence and repairing minimally
- Work at exam tempo with the two-pass sweep, post-set audits, and full simulations
- Self-score against rubric behavior and target the biggest remaining loss
AP Problem-Solving Bootcamp
How to read an AP question as a contract: extract signatures and bounds, widen small cases into full solutions, and hunt bugs by tracing.
Code Tracing Mastery
State tables, call frames, parameter passing, and object rows: a mechanical discipline for predicting any program's behavior.
Control Flow & Algorithmic Reasoning
The four loop machines (accumulator, counter, flag, sentinel), the five boundary traps, and composing them into combined algorithms.
Methods & Specification Problems
Translating written specifications into minimal, correct methods: helper decomposition, precondition discipline, and compositional debugging.
String Problem Solving
The Quick Reference API's edge behavior, character-level building (filter, map, split), and two-pointer patterns.
Array Mastery
The four traversal modes, index algebra (min/max, neighbors, rotation), and multi-pass shapes (count-then-act, pairwise dedup).
ArrayList Mastery
Removal discipline (backward loops, index invalidation), Integer boxing traps, and object collections — plus merge synthesis.
2D Array Mastery
Row-major orientation, column scans with per-column aggregation, neighbor guards, and position-finding with double early exits.
Classes & Object Interaction
State-transition thinking, aliasing across objects, and the constructor traps the exam loves — with a full class-design build.
Inheritance & Polymorphism
Dispatch tables, constructor chaining with super, the override-vs-overload trap, and polymorphic collections.
Recursion & Recursive Reasoning
Base-case design, frame-by-frame stack tracing with call counts, and two-branch decision trees.
Integrated Java Problems
Unlabeled problems: diagnose the machines first, eliminate near-misses with the four probes, and trace multi-pass programs.
MCQ Strategy & Error Clinic
Prediction-first answering, the trap taxonomy (families of wrong answers), and a personal error-clinic protocol.
FRQ Fundamentals
The four FRQ question types and scoring shape, the eight-step workflow, and answer conventions that earn points.
FRQ Class Design
Q2 spec-table translation: ordered mutators, helper decomposition, object-interaction discipline, and seam-bug repair.
FRQ ArrayList Analysis
Q3's one-method answers: count/match/process over object lists, token analysis, and multi-part helpers.
FRQ 2D Arrays
Q4's one-method answers: position reports, neighborhood transforms with the two-grid pattern, and navigational walks.
FRQ Debugging & Partial Credit
First-error localization, cascading-error discipline, and the salvage protocol for banking partial credit.
Timed Mixed Sets & Cumulative Review
Exam-tempo mixed problem sets with the two-pass sweep and post-set audit, plus a cumulative machine inventory.
Full Simulation & Exam Readiness
The four-FRQ simulation under exam structure, rubric-based self-scoring, and the course's exit readiness checklist.