free diagnosticupgrade
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.

5 topic guides available. Use the AP score calculator to estimate your exam score as you review.

start review notesreview topics
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.

Heaviest exam weight: Practice 3

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.

FRQ driver: Practice 2

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.

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

1

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.

open guide
2

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.

open guide
3

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.

open guide
4

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.

open guide
5

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.

open guide

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 taskWhat 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.
SkillWhere it appears
Write an algorithm using loops and conditionalsMCQ and all 4 FRQs
Build or extend a class with constructors and methodsFRQ types: Methods and Control Structures, Class Design
Use arrays or ArrayLists to store and process dataFRQ 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 taskExample question type
Trace a for or while loopWhat is printed after this loop executes?
Predict output from a recursive methodWhat value does this method return when called with n = 4?
Identify why code failsWhich 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 taskWhat the question looks like
Describe overall behaviorWhich statement best describes what this method does?
Identify a preconditionFor 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 typeWhat Practice 5 asks
A company collects user data without disclosureIdentify the ethical or legal issue with this practice
A programmer writes biased filtering codeExplain the social consequence of deploying this system
A student copies open-source code without attributionDetermine 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 guidesEach 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 weightIf 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 handPractice 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 specificationFor 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 scenarioThese 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 sessionThe 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 passRead 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 diveWork 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 sessionWork 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 5Read 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 fillUse 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.

browse guides

FRQ practice

Practice free-response reasoning and compare your answer with scoring guidance.

practice FRQs

Cheatsheets

Use unit cheatsheets for a quick visual review after you work through the notes.

open cheatsheets

Score calculator

Estimate your broader AP score goal after you review the course and exam format.

open calculator
Ready to review Computational Thinking Practices?Start with the notes, check the topic cards, and use the practice or resource links when they are available for this course.
start review notesreview topics
Next