AP exam review verified for 2027
AP Computer Science A Computational Thinking Practices Review
The five AP CSA Computational Thinking Practices define every skill the exam tests, from designing and writing Java code to tracing output, documenting behavior, and reasoning about computing's impact on society. Use this collection to identify which practices you need to strengthen and work through the topic guides in the order that fits your gaps.
Fiveable's AP Computer Science A Computational Thinking Practices review covers 5 topics, with guided practice questions for the unit.
5 topic guides available. Use the AP score calculator to estimate your exam score as you review.
AP exam review verified for 2027
What are the AP Computer Science A computational thinking practices?
AP CSA is organized around five Computational Thinking Practices rather than isolated topics. Every multiple-choice question and every free-response question is tagged to one of these practices, so understanding what each practice asks you to do is the first step toward targeted review.
Practice 3 (Analyze Code) carries the heaviest MCQ weight at roughly 37 to 53 percent, Practice 2 (Develop Code) drives all four FRQs, and Practices 1, 4, and 5 appear only on the multiple-choice section. Prioritize Practice 3 and Practice 2 for the biggest score impact.
FRQ driver: Practice 2
Smaller but scorable: Practices 1, 4, and 5
Practice 1 (Design Code) asks you to choose a program structure or extract information from data. Practice 4 (Document Code) asks you to describe overall behavior or identify preconditions. Practice 5 (Use Computers Responsibly) asks you to reason about ethical, legal, and social outcomes. Each appears only on MCQ and together they represent meaningful points worth preparing for.
Why the practices framework matters for review
When you miss a question, identifying which practice it tests tells you exactly what skill broke down. A wrong answer on a tracing question points to Practice 3 gaps. A wrong answer on a class-design question points to Practice 2 or Practice 1. Using the practice labels as a diagnostic tool turns every mistake into a specific study action rather than a vague sense that you need to review Java.
Review study guides
Design Code
Covers choosing program designs and extracting knowledge from data. Appears only on MCQ. Start here if you struggle with deciding between algorithm or data structure options before writing any code.
Develop Code
Covers writing algorithms, data abstractions, and procedural abstractions in Java. Tested on MCQ and all four FRQs. This is the practice with the broadest exam impact and the one to prioritize if you are short on time.
Analyze Code
Covers tracing output, predicting results from abstractions, and identifying errors. Carries the heaviest MCQ weight of any practice. If you want to move your multiple-choice score, this guide is the highest-leverage starting point.
Document Code and Computing Systems
Covers describing code behavior in plain language and identifying preconditions. Appears only on MCQ. Useful for students who can trace code but struggle to articulate what a method does at a high level.
Use Computers Responsibly
Covers computing's effects on society, the economy, and culture. Appears only on MCQ. Review this guide to prepare for scenario-based questions about ethics, privacy, and legal responsibilities in computing.
Computational thinking practices review notes
Practice 1
Design Code: choosing structures and extracting information
Practice 1 asks you to determine an appropriate program design before any code is written and to figure out what a data set tells you. On the exam it appears only in multiple-choice questions and carries a smaller weight than Practices 2 and 3. The topic guide walks through how to evaluate algorithm choices and what it means to extract knowledge from data.
- Program design: Deciding how a solution should be structured, including which data structures, control flow patterns, and method decompositions fit the problem before writing syntax.
- Extracting knowledge from data: Reading a data set or output and drawing a conclusion about what the program or data represents, rather than tracing code execution.
Can you look at a problem description and identify whether an array, ArrayList, or a loop-based approach is the better design choice? That decision-making is the core of Practice 1.
| Practice 1 task | What the exam asks |
|---|---|
| Determine program design (1.A) | Choose between two algorithm or data structure options for a described problem |
| Extract knowledge from data (1.B) | Interpret what a data set or output reveals about a program's behavior or purpose |
Practice 2
Develop Code: writing working Java programs
Practice 2 is the most consequential practice for your overall score because it drives all four free-response questions and a large share of the multiple-choice section. The topic guide covers writing algorithms, using data abstractions like arrays and ArrayLists, and applying procedural abstractions through method calls and class design.
- Algorithm implementation: Translating a described procedure into correct Java syntax, including loops, conditionals, and method calls that produce the intended result.
- Data abstraction: Using arrays, ArrayLists, or objects to organize and manipulate collections of data in a program.
- Procedural abstraction: Writing and calling methods, including constructors and accessor or mutator methods, to break a problem into reusable pieces.
On every FRQ you must write code that compiles and runs correctly. Practice writing complete method bodies from a specification, not just filling in blanks.
| Skill | Where it appears |
|---|---|
| Write an algorithm using loops and conditionals | MCQ and all 4 FRQs |
| Build or extend a class with constructors and methods | FRQ types: Methods and Control Structures, Class Design |
| Use arrays or ArrayLists to store and process data | FRQ types: Array/ArrayList, 2D Array |
Practice 3
Analyze Code: tracing output and identifying errors
Practice 3 is the highest-weighted practice on the multiple-choice section at roughly 37 to 53 percent. You read existing Java code and determine what it outputs, what it returns, or why it fails. The topic guide covers tracing loops and recursion, predicting results from method calls, and distinguishing compile-time errors from logic errors.
- Code tracing: Stepping through a code segment line by line, tracking variable values and control flow to determine the final output or return value.
- Compile-time error: A syntax or type error that prevents the program from compiling, such as a missing semicolon or an incompatible type assignment.
- Logic error: A mistake in the algorithm that allows the program to compile and run but produces an incorrect result.
Pick any loop-heavy MCQ and trace it by hand on paper, writing variable values at each iteration. If your trace matches the correct answer, your Practice 3 foundation is solid.
| Analysis task | Example question type |
|---|---|
| Trace a for or while loop | What is printed after this loop executes? |
| Predict output from a recursive method | What value does this method return when called with n = 4? |
| Identify why code fails | Which of the following best explains why this segment does not compile? |
Practice 4
Document Code: describing behavior and preconditions
Practice 4 asks you to explain what a code segment does in plain language and to identify the initial conditions, called preconditions, that a segment requires to work as intended. It appears only on the multiple-choice section and carries roughly 10 to 15 percent of the MCQ weight. The topic guide focuses on reading a method and writing or selecting an accurate description of its overall purpose.
- Precondition: A condition that must be true before a code segment executes for it to produce the correct result, such as a parameter being non-null or within a valid range.
- Postcondition: A condition that is guaranteed to be true after a code segment executes correctly, describing the state of variables or the return value.
Read a short method and write one sentence describing what it does without mentioning specific variable names. If you can do that accurately, you are ready for Practice 4 questions.
| Practice 4 task | What the question looks like |
|---|---|
| Describe overall behavior | Which statement best describes what this method does? |
| Identify a precondition | For this segment to work as intended, which condition must be true before it executes? |
Practice 5
Use Computers Responsibly: computing and society
Practice 5 shifts away from Java syntax entirely. You reason about how computing affects society, the economy, and culture, including ethical, legal, and social consequences of programming decisions. It appears only on the multiple-choice section. The topic guide connects to topics like ethical and social issues in computing, privacy, and the responsibilities programmers carry when building systems.
- Ethical computing: Evaluating whether a programming decision or system design respects user privacy, avoids harm, and complies with legal standards.
- Social impact of computing: Identifying how a program, algorithm, or data system affects individuals, communities, or institutions beyond its immediate technical function.
Practice 5 questions often present a scenario and ask you to identify the most responsible or legally appropriate action. Focus on reasoning about consequences, not on Java syntax.
| Scenario type | What Practice 5 asks |
|---|---|
| A company collects user data without disclosure | Identify the ethical or legal issue with this practice |
| A programmer writes biased filtering code | Explain the social consequence of deploying this system |
| A student copies open-source code without attribution | Determine whether this use is legally or ethically appropriate |
Common mistakes
Confusing Practice 3 tracing with Practice 4 describing
Tracing asks what a specific output is. Describing asks what the method does overall. Students who only practice tracing often miss Practice 4 questions because they give a specific output instead of a general behavioral description.
Skipping Practice 2 review because it feels like general Java
Practice 2 is not just knowing Java syntax. It specifically tests whether you can translate a written specification into correct code under exam conditions. Students who skip structured Practice 2 review often lose points on FRQs by writing code that is syntactically close but logically wrong.
Underestimating Practice 5 because it has no code
Practice 5 questions are not automatically easy. They require you to apply specific reasoning about ethics, privacy, and legal standards to unfamiliar scenarios. Treating them as common-sense questions without preparation leads to avoidable mistakes.
Tracing loops without tracking every variable
A common Practice 3 error is tracking only the loop counter and ignoring accumulator or flag variables. Write down every variable that changes at each iteration, not just the one that controls the loop.
Assuming Practice 1 is just about picking the right data structure
Practice 1 also includes extracting knowledge from data, which is a different skill. Students who only review data structure selection miss the data-interpretation questions that Practice 1 also covers.
How this review fits into AP prep
Practice 3 dominates the multiple-choice section
With roughly 37 to 53 percent of MCQ weight, Practice 3 is the single biggest driver of your multiple-choice score. Every question that shows you a code segment and asks what it outputs or why it fails is a Practice 3 question. Building fast, accurate tracing habits is the most direct path to a higher MCQ score.
Practice 2 is the only practice on the free-response section
All four FRQ questions, covering methods and control structures, classes, array and ArrayList manipulation, and 2D arrays, require you to write working Java code. That is Practice 2. No other practice is directly assessed on the FRQ section, so your ability to develop correct code determines your entire free-response score.
Practices 1, 4, and 5 are MCQ-only and collectively scorable
These three practices appear only in multiple-choice questions. Practice 1 asks you to choose a design or interpret data. Practice 4 asks you to describe behavior or identify preconditions. Practice 5 asks you to reason about computing's social and ethical consequences. Together they represent a meaningful portion of the MCQ section that rewards students who prepare specifically for each question type.
Review checklist
- Read all five topic guides
Each guide covers one practice in full. Read the overview section of each to confirm you understand what the practice asks before drilling into examples.
- Identify your weakest practice by exam weight
If you are focused on MCQ, prioritize Practice 3 first, then Practice 2. If you are focused on FRQs, Practice 2 is the only practice directly tested there. Use this ordering to sequence your review time.
- Trace at least one loop and one recursive method by hand
Practice 3 fluency comes from repetition. Write out variable values at each step without running the code. If your trace matches the expected output, move on. If not, re-read the Practice 3 guide.
- Write a complete method body from a specification
For Practice 2, pick a method description from the Practice 2 guide and write the full Java implementation without looking at the answer. Check that your method compiles logically and handles edge cases.
- Review one Practice 4 and one Practice 5 scenario
These practices carry smaller weights but are still scorable. Read one code-description question from the Practice 4 guide and one ethics scenario from the Practice 5 guide to confirm you can handle both question types.
- Use the AP score calculator after your review session
The score calculator on this page lets you estimate your AP exam score based on your current performance. Use it after reviewing to set a realistic target and identify whether you need another pass through any practice.
How to study computational thinking practices
Session 1: Orientation pass
Read the overview section of all five topic guides in one sitting. Your goal is to confirm you can name what each practice asks and roughly how much of the exam it covers. This takes about 30 minutes and gives you a map for the rest of your review.
Session 2: Practice 3 deep dive
Work through the Practice 3 topic guide in full. Focus on the tracing examples for loops and recursive methods. After each example, cover the answer and trace it yourself. Repeat until your traces are consistently correct.
Session 3: Practice 2 writing session
Work through the Practice 2 topic guide. For each worked example, write the full method body before reading the solution. Pay attention to how the guide handles edge cases and method signatures, since FRQ graders check both.
Session 4: Practices 1, 4, and 5
Read the Practice 1, Practice 4, and Practice 5 guides back to back. These are shorter reviews. For Practice 1, focus on the design-choice examples. For Practice 4, practice writing one-sentence behavioral descriptions. For Practice 5, work through the ethics scenarios.
Session 5: Score check and gap fill
Use the AP score calculator to estimate your estimated score range. If your estimate is lower than your goal, return to the topic guide for the practice where you feel least confident and re-read the sections you skimmed earlier.
More ways to review
Topic study guides
Open the individual guides for Computational Thinking Practices when you want a closer review of one topic.
Practice questions
Use AP-style practice after you review the notes so you can check what you understand.
FRQ practice
Practice free-response reasoning and compare your answer with scoring guidance.
Official unit cheatsheet
Open the Fiveable one-page unit review, then explore visual cheatsheets for a quick refresher.
Score calculator
Estimate your broader AP score goal after you review the course and exam format.
this subject printables
Print the cheatsheet bundle ($14) or full-length exam ($12) for this subject. Yours to keep, no subscription needed.
get printables