---
title: "AP Computer Science Principles Computational Thinking Practices | Fiveable"
description: "Learn the required computational thinking practices for AP Computer Science Principles with CED-aligned skill guides and examples across the course."
canonical: "https://fiveable.me/ap-comp-sci-p/computational-thinking-practices"
type: "unit"
subject: "AP Computer Science Principles"
unit: "Computational Thinking Practices"
---

# AP Computer Science Principles Computational Thinking Practices | Fiveable

## Overview

This page collects all six AP CSP computational thinking practice guides in one place. The practices range from designing solutions and writing algorithms to analyzing code, evaluating innovations, and working responsibly. Each guide explains the subskills, shows how the practice appears on the exam, and gives you concrete review strategies.

## AP CED Alignment

This unit hub is organized around AP Course and Exam Description topics, skills, and exam task types when they are available in the source data.
- Practice 1: Computational Solution Design
- Practice 2: Algorithms and Program Development
- Practice 3: Abstraction in Program Development
- Practice 4: Code Analysis
- Practice 5: Computing Innovations
- Practice 6: Responsible Computing
- Practices: Choosing the right guide for your review session

## Topics

- [Practice 1: Computational Solution Design](/ap-comp-sci-p/computational-thinking-practices/practice-1-computational-solution-design/study-guide/TkG1YlTvDFs731OB4aZ3): This guide covers how to investigate a task, design a method that fits the purpose, evaluate competing options, and use collaboration effectively. It is especially useful before you write your Create task responses about why you made the design choices you did.
- [Practice 2: Algorithms and Program Development](/ap-comp-sci-p/computational-thinking-practices/practice-2-algorithms-and-program-development/study-guide/yCIcMlA0naj9c7dn9YFm): This guide covers representing algorithms in plain language or diagrams (2.A) and implementing or tracing algorithms in code (2.B). Multiple-choice questions frequently hand you pseudocode and ask what it produces or how to fix it.
- [Practice 3: Abstraction in Program Development](/ap-comp-sci-p/computational-thinking-practices/practice-3-abstraction-in-program-development/study-guide/uZNTF63YRNQkvgSc4CYw): This guide covers using variables to stand in for data, building procedures that hide complexity, calling those procedures, and explaining why abstraction makes programs easier to write and change. The Create task scores you on whether your program uses meaningful abstraction.
- [Practice 4: Code Analysis](/ap-comp-sci-p/computational-thinking-practices/practice-4-code-analysis/study-guide/pRO6QyOT1eUebXzUUGKz): This guide covers the three subskills: explaining what a code segment does, tracing through code to find the output, and identifying and correcting errors. Code analysis questions are among the most common on the multiple-choice section.
- [Practice 5: Computing Innovations](/ap-comp-sci-p/computational-thinking-practices/practice-5-computing-innovations/study-guide/8pPKcgsn74JCj1uLzEtU): This guide covers how computing systems function, how data is collected and turned into knowledge, what beneficial and harmful impacts an innovation creates, and how legal and ethical considerations shape computing. This practice is multiple-choice only, so the guide focuses on reading and reasoning strategies.
- [Practice 6: Responsible Computing](/ap-comp-sci-p/computational-thinking-practices/practice-6-responsible-computing/study-guide/eGwL48W5kywOtEOBhAFU): This guide covers inclusive collaboration, safe and secure computing habits, and properly crediting the work of others. Because Practice 6 is not scored through a standalone question type, the guide explains where it does appear and how to handle it in your Create work.

## Review Notes

### Practices: Choosing the right guide for your review session

Each of the six guides in this collection covers one practice in depth, including its subskills, how it appears on the exam, and worked examples. If you are preparing for the multiple-choice section, prioritize Practices 2, 4, and 5 because they generate the highest volume of question types. If you are finalizing your Create task, focus on Practices 1, 2, 3, and 4 in that order.

- **Practice 1: Computational Solution Design**: Covers investigating problems, designing approaches, evaluating options, and using collaboration. Appears on multiple-choice and Create written responses.
- **Practice 2: Algorithms and Program Development**: Covers representing algorithms without code (2.A) and implementing or applying an algorithm (2.B). Both subskills appear on multiple-choice and Create.
- **Practice 3: Abstraction in Program Development**: Covers using variables to generalize data, building and calling procedures, and explaining why abstraction makes programs easier to manage. Appears on multiple-choice and Create.
- **Practice 4: Code Analysis**: Covers explaining how code functions (4.A), determining the result of code segments (4.B), and identifying and correcting errors (4.C). Appears on multiple-choice and Create.
- **Practice 5: Computing Innovations**: Covers how systems work, how data becomes knowledge, impacts of innovations, and legal and ethical evaluation. Multiple-choice only.
- **Practice 6: Responsible Computing**: Covers collaboration, safe computing habits, and crediting others. Not directly scored on multiple-choice or through a standalone Create response.

**Checkpoint:** Before moving to individual guides, identify which practice you feel least confident about. Start there rather than reviewing in order from 1 to 6.

Practice | Multiple-choice | Create task
--- | --- | ---
1: Computational Solution Design | Yes | Yes
2: Algorithms and Program Development | Yes | Yes
3: Abstraction in Program Development | Yes | Yes
4: Code Analysis | Yes | Yes
5: Computing Innovations | Yes | No

## Study Guides

- [Practice 1: Computational Solution Design](/ap-comp-sci-p/computational-thinking-practices/practice-1-computational-solution-design/study-guide/TkG1YlTvDFs731OB4aZ3)
- [Practice 2: Algorithms and Program Development](/ap-comp-sci-p/computational-thinking-practices/practice-2-algorithms-and-program-development/study-guide/yCIcMlA0naj9c7dn9YFm)
- [Practice 3: Abstraction in Program Development](/ap-comp-sci-p/computational-thinking-practices/practice-3-abstraction-in-program-development/study-guide/uZNTF63YRNQkvgSc4CYw)
- [Practice 4: Code Analysis](/ap-comp-sci-p/computational-thinking-practices/practice-4-code-analysis/study-guide/pRO6QyOT1eUebXzUUGKz)
- [Practice 5: Computing Innovations](/ap-comp-sci-p/computational-thinking-practices/practice-5-computing-innovations/study-guide/8pPKcgsn74JCj1uLzEtU)
- [Practice 6: Responsible Computing](/ap-comp-sci-p/computational-thinking-practices/practice-6-responsible-computing/study-guide/eGwL48W5kywOtEOBhAFU)

## Common Mistakes

- **Treating abstraction as just using variables**: Practice 3 is about more than naming a variable. The exam also asks you to explain why abstraction is useful, how a procedure hides complexity, and how calling a procedure with different parameters generalizes a solution. Students who only think about variables miss the procedural abstraction questions.
- **Skipping Practice 5 because it feels like general knowledge**: Practice 5 questions have specific vocabulary around data collection, storage, processing, and impacts. Terms like metadata, personally identifiable information, and digital divide appear in precise ways. Reviewing the Practice 5 guide helps you answer these questions accurately rather than relying on general intuition.
- **Assuming Practice 6 does not matter for the exam**: While Practice 6 is not scored through a standalone question type, collaboration and crediting sources do appear in multiple-choice scenarios and in the Create task context. Ignoring the guide entirely can cost points on questions about open-source licensing, Creative Commons, and collaborative development.
- **Confusing algorithm representation with implementation**: Practice 2 has two distinct subskills. Skill 2.A is about representing an algorithm without a programming language, using plain language or a diagram. Skill 2.B is about implementing and applying an algorithm in code. Exam questions test these separately, and mixing them up leads to answers that address the wrong skill.
- **Writing Create responses that describe code instead of explaining it**: Practice 4 subskill 4.A asks you to explain how a code segment functions, not just restate what the lines say. A response that says 'the loop runs ten times' without explaining what changes each iteration or what the result means will not earn full credit.

## Exam Connections

- **Multiple-choice questions name the practice in their scoring, not in the question**: When you see a multiple-choice question with a code segment, the question is testing Practice 2, 3, or 4 depending on what it asks. Recognizing the practice helps you focus: a question asking what a procedure returns is a Practice 4 trace task, while a question asking how to rewrite code to reduce repetition is a Practice 3 abstraction task.
- **Create task written responses are each tied to specific practice subskills**: The Create task prompts are designed to elicit evidence of Practices 1 through 4. The response about your algorithm targets Practice 2. The response about your procedure and what it does targets Practices 3 and 4. Knowing which practice each prompt targets helps you write responses that include the right kind of evidence rather than general descriptions.
- **Practice 5 questions often use a scenario format with a named innovation**: A typical Practice 5 multiple-choice question introduces a technology, describes how it collects or uses data, and then asks about impacts, privacy concerns, or ethical considerations. The Practice 5 guide prepares you to read these scenarios efficiently and match the details to the correct category of impact or the correct legal concept.

## Final Review Checklist

- **Read each practice guide at least once**: All six guides are available in this collection. Even if you feel confident in a practice, skimming the guide takes a few minutes and often surfaces a subskill or exam format you had not considered.
- **Map your Create task to Practices 1 through 4**: Go through your Create written responses and identify which practice each response is targeting. If a response does not clearly demonstrate the relevant practice, revise it before submission.
- **Prioritize code tracing for the multiple-choice section**: Practice 4 subskill 4.B (determining the result of code segments) appears repeatedly on the multiple-choice section. Use the Practice 4 guide to review how to trace loops, conditionals, and procedure calls step by step.
- **Review Practice 5 as a reading comprehension skill**: Computing Innovations questions often present a scenario about a real or fictional technology and ask you to evaluate its impacts or identify how data is used. The Practice 5 guide explains the categories of impacts and the legal and ethical vocabulary the exam uses.
- **Use the score calculator after your review**: Once you have worked through the guides, use the AP score calculator available on this page to estimate your score based on your current confidence across sections. This helps you decide whether to spend remaining time on multiple-choice skills or Create task revisions.

## Study Plan

- **Session 1: Diagnose your weakest practice**: Read the overview section of each practice guide quickly. Note which practices have subskills or exam formats you cannot confidently explain. Rank them from least to most confident. This ranking drives the rest of your study plan.
- **Session 2: Deep review of code-heavy practices**: Spend focused time on Practice 2 and Practice 4. Work through the algorithm representation examples in the Practice 2 guide and the code tracing examples in the Practice 4 guide. These two practices generate the most multiple-choice questions involving pseudocode.
- **Session 3: Create task alignment**: Open your Create task draft alongside the guides for Practices 1, 2, 3, and 4. Check each written response against the subskill it is supposed to demonstrate. Revise any response that describes rather than explains, or that does not clearly show design reasoning, algorithm logic, abstraction, or code analysis.
- **Session 4: Practice 5 scenario review**: Read the Practice 5 guide with attention to the categories of impacts (beneficial, harmful, intended, unintended) and the legal and ethical vocabulary. Practice applying these categories to a computing innovation you are familiar with before the exam.
- **Session 5: Score estimate and final targeting**: Use the score calculator to estimate your current score. If your multiple-choice confidence is lower, return to Practice 4 code tracing. If your Create task responses feel weak, return to the Practice 1 guide on design reasoning. Spend the final session only on the area the calculator reveals as your biggest gap.

## More Ways To Review

- [Topic study guides](/ap-comp-sci-p/computational-thinking-practices#topics)
- [FRQ practice](/ap-comp-sci-p/frq-practice)
- [Cheatsheets](/ap-comp-sci-p/cheatsheets/computational-thinking-practices)