AP CS Principles Exam Review: Key Concepts

The AP Computer Science Principles exam covers a broad range of computing topics, from binary numbers to cybersecurity to programming with pseudocode. Unlike AP CS A, which goes deep on Java, AP CSP tests your understanding of computing as a whole. The challenge isn't depth; it's breadth. You need to know a little about a lot.

This guide walks through every key concept organized by the College Board's 5 Big Ideas, plus the Create Performance Task and essential exam strategies. Use it as a final review before the exam or as a study roadmap to identify your weak spots.

Exam Format at a Glance

The multiple-choice section includes both single-select and multiple-select questions. Multiple-select questions tell you exactly how many answers to choose (usually "Select TWO answers"). There is no penalty for wrong answers, so never leave a question blank.

Big Idea 1: Creative Development

This Big Idea focuses on how programs are designed and built collaboratively. It's tested less heavily in the multiple-choice section, but it's central to the Create Performance Task.

Key concepts

• Collaboration: working with others improves programs by incorporating diverse perspectives. Pair programming, code reviews, and user testing are all forms of collaboration.
• Program design: programs are developed iteratively. You start with an idea, build a prototype, test it, and refine it. This cycle repeats.
• Program documentation: comments and documentation help others (and your future self) understand what code does and why.
• Identifying inputs and outputs: every program takes some form of input (user actions, sensor data, files) and produces output (text, graphics, sound, data).

What to watch for on the exam: questions about the benefits of collaboration, iterative development, and how feedback improves a program. These are usually the most straightforward questions on the test.

Big Idea 2: Data

Data questions make up a significant portion of the exam. You need to understand how data is represented, stored, compressed, and analyzed.

Binary and number systems

• All digital data is stored as binary (base 2): sequences of 0s and 1s.
• Each binary digit is a bit. Eight bits make a byte.
• With n bits, you can represent 2ⁿ different values. For example, 8 bits can represent 256 values (0 through 255).
• Know how to convert between binary and decimal. For example, binary 1101 = 8 + 4 + 0 + 1 = 13 in decimal.

Data compression

• Lossless compression reduces file size without losing any data. The original can be perfectly reconstructed. Example: ZIP files.
• Lossy compression reduces file size by permanently removing some data. The original cannot be perfectly reconstructed, but the result is "close enough" for human perception. Examples: JPEG images, MP3 audio.
• Lossy compression achieves smaller file sizes than lossless, but with a tradeoff in quality.

Data and information

• Data becomes useful when it's cleaned, organized, and analyzed to extract information.
• Large data sets can reveal patterns, trends, and correlations that small data sets cannot.
• Metadata is data about data: file creation date, image resolution, author name, GPS coordinates in a photo.
• Correlation does not imply causation. Just because two variables trend together doesn't mean one causes the other.

Overflow and roundoff

• Overflow: when a number exceeds the maximum value that can be stored in a fixed number of bits. For example, adding 1 to 255 in an 8-bit unsigned system wraps around to 0.
• Roundoff errors: computers use a fixed number of bits to represent decimal numbers, so some values (like 1/3 or 0.1) cannot be represented exactly. This can cause small errors in calculations.

What to watch for on the exam: binary conversion questions, questions about how many values n bits can represent, and data analysis scenarios where you interpret a table or chart.

Big Idea 3: Algorithms and Programming

This is the largest Big Idea and the one most heavily tested. You need to read, trace, and write pseudocode fluently.

Variables and data types

• A variable stores a value that can change. In AP pseudocode, assignment uses the arrow: x ← 5.
• Common data types: numbers, strings (text), and Booleans (true/false).
• A list stores an ordered sequence of values. In AP pseudocode, lists are 1-indexed (the first element is at index 1, not 0).

Operators

• Arithmetic: +, -, *, /, MOD (remainder after division)
• Comparison: =, ≠, >, <, ≥, ≤
• Logical: AND, OR, NOT

Conditionals

The AP pseudocode uses this format:

IF (condition)
{
    // runs if condition is true
}
ELSE
{
    // runs if condition is false
}

Nested conditionals place one IF inside another. Understand the difference between nested IF statements and sequential IF statements: nested conditions are only checked when the outer condition is true, while sequential conditions are always checked.

Loops

REPEAT n TIMES
{
    // runs n times
}

REPEAT UNTIL (condition)
{
    // runs until condition becomes true
}

A REPEAT UNTIL loop checks the condition before each iteration. If the condition is already true, the loop body never executes.

Lists

List operations you need to know:

Critical reminder: AP pseudocode lists are 1-indexed. The first element is aList[1], not aList[0]. This trips up students who are used to Python or Java.

Procedures (functions)

• A procedure is a named block of code that performs a specific task. Procedures help organize code and avoid repetition.
• Parameters are inputs to a procedure. Arguments are the actual values passed when the procedure is called.
• A procedure can RETURN a value, or it can simply perform actions without returning anything.
• Procedural abstraction: you can use a procedure without knowing how it works internally. You only need to know what it takes as input and what it returns.

Algorithms you must know

• Linear search: check each element one at a time until you find the target or reach the end. Works on any list. Takes up to n steps for a list of n elements.
• Binary search: repeatedly divide a sorted list in half. Much faster than linear search for large lists: takes at most log₂(n) steps. Only works on sorted data.
• Know the difference: binary search is more efficient, but it requires the list to be sorted first.

Algorithm efficiency

• Reasonable time: an algorithm runs in reasonable time if the number of steps grows as a polynomial function of the input size (like n, n², or n³).
• Unreasonable time: an algorithm runs in unreasonable time if the number of steps grows exponentially (like 2ⁿ). These become impractical for even moderately large inputs.
• Heuristic: an approach that finds a good-enough solution when finding the optimal solution takes unreasonable time.

What to watch for on the exam: pseudocode tracing questions are the most common. You'll be given code and asked what value a variable holds after execution, or what the procedure returns. Practice tracing carefully, writing down variable values at each step.

Big Idea 4: Computer Systems and Networks

This Big Idea covers how the internet works and how computers communicate. It's typically 10 to 15% of the exam.

The internet

• The internet is a network of networks, connected through routers, switches, and cables.
• Data is broken into packets that travel independently across the network and are reassembled at the destination.
• Packets can take different routes to the same destination. This is called redundancy, and it makes the network fault-tolerant: if one path fails, packets can take another.

Protocols

Fault tolerance

• A fault-tolerant system continues to function even when parts of it fail.
• Redundancy (multiple paths, backup servers) is the primary mechanism for fault tolerance.
• A network with only one path between two points has a single point of failure: if that connection goes down, communication is lost.

Parallel and distributed computing

• Sequential computing: tasks run one at a time. Total time = sum of all task times.
• Parallel computing: tasks run simultaneously on multiple processors. Total time is limited by the slowest task (not the sum). Speedup is significant but never perfect because some tasks depend on others.
• Distributed computing: computation is spread across multiple computers connected by a network.

What to watch for on the exam: diagram-based questions asking whether a network is fault-tolerant (can device A still reach device B if a connection is removed?), and questions about which protocol handles a given task.

Big Idea 5: Impact of Computing

These questions test your understanding of how computing affects people and society. They often appear as scenario-based multiple-choice questions.

Digital divide

• The digital divide refers to unequal access to computing and the internet based on geography, income, age, or disability.
• It affects education, employment, and civic participation. People without internet access are cut off from online resources that others take for granted.

Bias in computing

• Algorithms can reflect and amplify biases in the data they're trained on. If training data underrepresents a group, the algorithm's predictions for that group will be less accurate.
• Bias can also be introduced through the design choices of programmers who may not consider all user groups.

Crowdsourcing

• Crowdsourcing uses contributions from a large number of people to solve problems or gather data. Examples: Wikipedia, citizen science projects, open-source software.
• Benefits: diverse perspectives, large-scale data collection. Risks: quality control, misinformation.

Legal and ethical concerns

• Intellectual property: software, music, and other digital content are protected by copyright. Open-source licenses allow sharing and modification under specific terms.
• Creative Commons: a set of licenses that let creators specify how others can use their work.
• Privacy: collecting and storing personal data raises concerns about who has access and how it's used. Data breaches expose private information.
• PII (Personally Identifiable Information): data that can identify an individual, such as name, Social Security number, or location data. Protecting PII is a core responsibility.

Cybersecurity

• Phishing: tricking someone into revealing sensitive information through fake emails or websites.
• Malware: software designed to damage or gain unauthorized access to a system. Includes viruses, ransomware, and keyloggers.
• Encryption: encoding data so that only authorized parties can read it. Symmetric encryption uses one key; public-key (asymmetric) encryption uses a pair of keys (public and private).
• Multi-factor authentication: using two or more methods to verify identity (something you know, something you have, something you are).

What to watch for on the exam: scenario-based questions asking you to identify a privacy concern, a source of bias, or a benefit/risk of a computing innovation. Read these carefully; the correct answer is usually the most specific and least extreme option.

The Create Performance Task

The Create Task is worth 30% of your score. You submit it before exam day, so you have time to do it well. Here's what you need to include:

What you submit

1. Your program code (as a video or PDF)
2. A video demonstrating your program running (under 1 minute, no narration required)
3. Written responses to four prompts about your code

Rubric requirements

The Create Task is scored on 6 criteria, each worth 1 point:

Tips for a strong Create Task

• Pick a program you understand completely. Complexity doesn't earn extra points. A well-explained simple program scores higher than a complex one you can't explain clearly.
• Make sure your procedure has a parameter that actually matters. The procedure should behave differently based on the argument passed in.
• Your procedure must contain sequencing, selection, and iteration. A loop with a conditional inside satisfies both iteration and selection. Add sequential statements before or after for sequencing.
• For the testing prompt, describe specific arguments and results. Don't say "I tested when the list is empty." Instead say "I called filterScores(emptyList) and the result was an empty list."
• Purpose vs. function: purpose is the problem your program solves or why someone would use it. Function is the specific input, processing, and output. Keep them clearly distinct in your response.

AP Pseudocode Quick Reference

The exam uses its own pseudocode language. You don't need to memorize every detail (a reference sheet is provided during the exam), but being comfortable with the syntax will save you time. Here are the constructs that appear most frequently:

Exam Day Strategies

Time management

You have 2 hours for 70 questions, which is approximately 1 minute and 43 seconds per question. That's tight. Here's how to stay on pace:

• First pass (60 minutes): answer every question you can handle quickly. Skip anything that requires long pseudocode tracing or that you're unsure about. Mark skipped questions.
• Second pass (50 minutes): return to marked questions and work through them carefully.
• Final check (10 minutes): review flagged answers and make sure nothing is blank.

Pseudocode tracing tips

• Write it down. Don't try to trace code in your head. Make a table with columns for each variable and update values as you step through the code line by line.
• Watch for off-by-one errors. Remember: AP lists start at index 1, RANDOM(1, 3) can return 1, 2, or 3 (inclusive), and REPEAT 3 TIMES runs exactly 3 times.
• Check loop boundaries. For REPEAT UNTIL, the condition is checked before each iteration. The loop stops as soon as the condition becomes true.

Eliminating wrong answers

• On "which of the following is true" questions, eliminate options with absolute language ("always," "never," "guarantees") unless the statement is genuinely always true.
• For code comparison questions ("which code segment produces the same result"), trace both segments with a simple test case. If they produce different results for even one case, they're not equivalent.
• For multiple-select questions, evaluate each option independently. Don't let one choice influence your judgment of another.

Common Mistakes to Avoid

1. Confusing the number of bits with the number of values. With 3 bits you can represent 8 values (2³ = 8), not 3.
2. Forgetting that AP lists are 1-indexed. aList[1] is the first element. There is no aList[0].
3. Mixing up lossy and lossless compression. Lossy = permanent quality loss, smaller files. Lossless = no quality loss, original fully recoverable.
4. Confusing sequencing, selection, and iteration. Sequencing = statements running in order. Selection = conditionals (IF). Iteration = loops (REPEAT).
5. Thinking binary search works on unsorted data. Binary search requires a sorted list. Linear search works on any list.
6. Confusing correlation with causation. Data showing that two things happen together doesn't prove one causes the other.
7. Confusing purpose and function on the Create Task. Purpose = why the program exists. Function = what it does with inputs and outputs.

Study Plan for the Final Week

If you have one week before the exam, here's how to spend it:

Ready to Prep with an Expert?

ExamReadyUSA's 4-week AP CSP Crash Course covers all 5 Big Ideas, includes graded MCQ practice sets, Create Task feedback, and a full mock exam. Groups are capped at 5 students, and every session is taught by Namrata Poladia, a College Board AP Reader who scores real AP exams.