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 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.
Analyzing code means tracing statement-by-statement execution, predicting output from methods and loops, and explaining compile or logic errors. This practice alone accounts for more than a third of the multiple-choice section, so fluency with tracing is the single highest-leverage skill to build.
Every free-response question requires you to write working Java code. Practice 2 covers translating an algorithm into correct syntax, building classes and objects, and calling methods. It also carries 22 to 38 percent of the MCQ weight, making it the most broadly tested practice on the exam.
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.
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.
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.
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.
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.
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.
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.
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.
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 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.
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 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.
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 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.
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 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.
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 |
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
this subject printables
Print the cheatsheet bundle ($14) or full-length exam ($12) for this subject. Yours to keep, no subscription needed.
get printables