AP CSP CED Explained
What’s on the AP CSP Exam: Every Topic, Explained (2025–2026)
Last reviewed: March 2026 — reflects the official College Board AP Computer Science Principles Course and Exam Description (CED), effective Fall 2023.The AP Computer Science Principles exam tests five Big Ideas across 70 MCQ questions. There is also a Create Performance Task worth 30% of your score that is submitted before the exam date. This page translates every CED section into plain English — what it means, what the exam asks, and the trap most students fall into.
Use this as your master reference. Every topic listed is fair game for the May 14, 2026 exam. The exam uses its own pseudocode language — not Java, Python, or any specific language — so the concepts matter more than syntax.
The AP CSP score comes from two separate components: 70 MCQ questions (70%) taken on exam day, and the Create Performance Task (30%) submitted approximately 3 weeks before the exam. You cannot make up a low MCQ score with a great Create Task or vice versa — both matter independently. The MCQ questions use College Board pseudocode, not any real programming language.
The last section of the MCQ exam has questions that require you to select two correct answers, not one. These are worth the same as single-answer questions. Read the instructions carefully on exam day — selecting only one answer on a two-answer question earns zero points.
Big Idea 1: Creative Development (CRD)
~10–13% of exam — collaboration, program design, development process, debuggingBig Idea 1 is about how programs are made — not the code itself, but the process of designing, building, and fixing software. The exam tests whether you understand the development lifecycle and the role of collaboration and testing.
Collaboration
In plain English: Working with others produces better software. Diverse teams bring different perspectives that improve problem-solving and reduce bias. Pair programming and code review are common collaboration strategies.
Exam tests: Benefits of collaboration, how diverse perspectives improve outcomes, what collaboration looks like in software development.
⚠ Trap:The exam asks about the VALUE of collaboration, not just that it happens. The answer is almost always about multiple perspectives catching errors or reducing bias.
Program Function and Purpose
In plain English: Programs exist to solve problems or express creativity. The purpose of a program is what it is intended to do. The function is what it actually does. These two may differ if there are bugs.
Exam tests: Identifying a program's purpose from a description, understanding input/output relationships, recognizing the difference between intended and actual behavior.
⚠ Trap:Purpose (what it's meant to do) and function (what it actually does) are different concepts. If a program has a bug, its function does not match its purpose.
Program Design and Development
In plain English: Programs are built iteratively: design, implement, test, revise. Pseudocode and flowcharts help plan programs before writing code. Comments document the code for others.
Exam tests: Understanding the iterative development process, reading pseudocode, identifying what documentation accomplishes.
⚠ Trap:Iterative development means you expect to revise. The exam often asks about why iterative development is beneficial — the answer is that it allows finding and fixing errors earlier.
Identifying and Correcting Errors
In plain English: Four types of errors: syntax (code won't run), logic (wrong output), runtime (crashes while running), overflow (value exceeds storage). Testing and debugging are ways to find and fix errors.
Exam tests: Identifying which type of error a code fragment contains, understanding what causes each error type, knowing that testing can find but not prove the absence of errors.
⚠ Trap:Testing can show a program has errors but cannot prove it is error-free. This distinction appears frequently on the exam.
Full reference: Big Idea 1 Study Guide
Big Idea 2: Data (DAT)
~17–22% of exam — binary, data compression, analyzing data, privacyBig Idea 2 covers how data is represented, stored, and used. Binary representation is the foundation. Data compression, metadata, and privacy implications are all tested. This big idea overlaps with real-world scenarios the exam loves to use.
Binary Numbers
In plain English: All data in computers is stored as binary (0s and 1s). An integer uses a fixed number of bits. More bits = larger range of values. Converting between binary and decimal is tested directly.
Exam tests: Converting binary to decimal and back, understanding what happens when a value exceeds its bit limit (overflow), knowing that 8 bits = 1 byte.
⚠ Trap:Overflow occurs when a value is too large for its bit representation. The exam gives you a binary number that exceeds the available bits and asks what happens — the answer is the value overflows (wraps around or loses precision).
Data Compression
In plain English: Lossless compression reduces file size without losing any data (can restore original exactly). Lossy compression reduces size by permanently discarding some data. Trade-off: smaller size vs. quality.
Exam tests: Distinguishing lossless from lossy compression, understanding when each is appropriate, knowing that compression reduces storage and transmission costs.
⚠ Trap:Lossless = exact original can be restored (text files, zip). Lossy = original cannot be fully restored (JPEG images, MP3 audio). Mixing these up is the #1 trap on Data questions.
Extracting Information from Data
In plain English: Data sets can reveal patterns, trends, and correlations. More data generally allows for more accurate conclusions. Visualization (charts, graphs) makes patterns easier to identify.
Exam tests: Reading data visualizations, identifying trends and correlations, understanding that correlation does not imply causation.
⚠ Trap:Correlation means two things change together. Causation means one causes the other. The exam frequently presents a data scenario and asks if it proves causation — it never does from correlation alone.
Using Programs with Data
In plain English: Programs can process large data sets to find patterns humans could not find manually. Combining data sets can reveal new information. Metadata (data about data) can reveal information even when the data itself is private.
Exam tests: Understanding how programs process data sets, reading simple data manipulation pseudocode, knowing what metadata reveals.
⚠ Trap:Metadata can be as revealing as the data itself. Phone call metadata (who you called, when, how long) can reveal patterns even without the call content. This is a high-frequency exam topic.
Full reference: Big Idea 2 Study Guide
Big Idea 3: Algorithms and Programming (AAP)
~30–35% of exam — the heaviest Big Idea — variables, lists, procedures, algorithmsBig Idea 3 is the largest and most technically demanding. It covers all the programming concepts tested on the exam using College Board pseudocode. No specific programming language is required, but you must be comfortable tracing code written in the AP reference format.
Variables and Assignments
In plain English: Variables store values that can change. The assignment operator (← in AP pseudocode) sets a variable's value. Variables can hold numbers, booleans, strings, or lists.
Exam tests: Tracing code with variable assignments, predicting variable values after a series of operations.
⚠ Trap:In AP pseudocode, a ← b assigns b's value to a. This is not checking equality. After x ← 5 then x ← x + 1, x is 6.
Data Abstraction
In plain English: Data abstraction uses lists and procedures to manage complexity. Instead of working with individual values, group related data into a list. Abstraction hides implementation details.
Exam tests: Identifying when a list replaces multiple variables, understanding how abstraction reduces complexity, tracing list operations.
⚠ Trap:If you have variables score1, score2, score3 and replace them with a list scores, that is data abstraction. The exam asks why this is beneficial — it manages complexity and makes code easier to modify.
Mathematical Expressions
In plain English: AP pseudocode uses standard arithmetic: +, -, *, /, and MOD (remainder). Division always produces a decimal result in CSP pseudocode (unlike Java).
Exam tests: Evaluating arithmetic expressions, using MOD to check divisibility or wrap values.
⚠ Trap:MOD is the remainder operator. 17 MOD 5 = 2. Common use: check if a number is even with n MOD 2 = 0. In AP pseudocode, division is NOT integer division — 7 / 2 = 3.5.
Strings
In plain English: Strings are sequences of characters. Operations include concatenation (joining), finding length, and extracting substrings. Strings are compared with = for equality.
Exam tests: Tracing string operations, concatenating strings with other data types, understanding string indexing.
⚠ Trap:AP pseudocode uses 1-based indexing for strings (first character is at index 1, not 0). This differs from Java and Python.
Boolean Expressions
In plain English: Boolean expressions evaluate to true or false. Operators: =, ≠, >, <, ≥, ≤. Combined with AND, OR, NOT.
Exam tests: Evaluating boolean expressions, tracing code with conditional logic, identifying when conditions are true or false.
⚠ Trap:AND requires both sides true. OR requires at least one. NOT flips the value. The exam gives complex nested boolean expressions and asks for the result — work through them step by step.
Conditionals
In plain English: IF/ELSE statements execute different code based on a condition. The IF block runs when the condition is true; the ELSE block runs when false.
Exam tests: Tracing IF/ELSE code, identifying which branch executes for given inputs.
⚠ Trap:The ELSE block only executes when the IF condition is false. If there is no ELSE, nothing happens when the condition is false — this is valid, not an error.
Nested Conditionals
In plain English: An IF/ELSE inside another IF/ELSE. Used when decisions depend on multiple conditions checked in sequence. Inner conditions only evaluate when outer conditions are met.
Exam tests: Tracing nested conditional logic with multiple inputs, predicting output from complex branching.
⚠ Trap:Only evaluate the inner condition if the outer condition was true. The exam gives you deeply nested code and a specific input — trace carefully, one level at a time.
Iteration
In plain English: Two loop types: REPEAT n TIMES (runs exactly n times) and REPEAT UNTIL (condition) (runs until condition is true). Loops can contain any code including other loops.
Exam tests: Counting loop iterations, tracing loop variable values, predicting output after a loop completes.
⚠ Trap:REPEAT UNTIL checks the condition AFTER each iteration in some contexts. More importantly: if the condition starts true, the loop may still run once. Read carefully.
Developing Algorithms
In plain English: An algorithm is a step-by-step process that solves a problem. Algorithms can be expressed as pseudocode, flowcharts, or natural language. The same problem can have multiple correct algorithms.
Exam tests: Identifying what an algorithm does, tracing algorithm execution, recognizing equivalent algorithms.
⚠ Trap:The exam often shows two algorithms and asks if they produce the same result for all inputs. Test with edge cases (empty input, largest possible value) not just typical inputs.
Lists
In plain English: Lists store multiple values in sequence. Access by index (1-based). Operations: INSERT, APPEND, REMOVE, LENGTH. FOR EACH item IN list traverses every element.
Exam tests: Tracing list operations, writing loops that process all elements, predicting list contents after insertions and removals.
⚠ Trap:AP pseudocode uses 1-based indexing. The first element is at index 1. After REMOVE(list, 2), all elements after position 2 shift left by one position.
Binary Search
In plain English: Binary search finds a value in a sorted list by repeatedly halving the search range. Much faster than linear search for large lists. Requires sorted data.
Exam tests: Tracing binary search steps, counting the number of comparisons needed, understanding why sorted data is required.
⚠ Trap:Binary search on unsorted data produces incorrect results. The exam will test this. Also: binary search is O(log n) — for a list of 1024 elements, it takes at most 10 comparisons.
Calling Procedures
In plain English: A procedure (function) is called by its name with arguments. The procedure runs, then control returns to where it was called. Procedures can return values or not.
Exam tests: Reading procedure calls, understanding parameter passing, tracing code that calls procedures.
⚠ Trap:The return value of a procedure must be used (stored or displayed) or it is lost. Calling a procedure that returns a value without capturing it is valid but discards the result.
Developing Procedures
In plain English: Procedures take parameters and execute a block of code. They can be reused multiple times. Procedural abstraction hides implementation details from the caller.
Exam tests: Writing procedures, understanding how parameters work, recognizing procedural abstraction.
⚠ Trap:Parameters receive copies of the values passed in. Changing a parameter inside the procedure does not change the original variable in the calling code.
Libraries
In plain English: Libraries provide pre-written procedures that programmers can call without writing the code themselves. APIs define how to use a library. Using libraries reduces development time.
Exam tests: Understanding the purpose of libraries and APIs, recognizing when using a library is appropriate.
⚠ Trap:You do not need to know how a library procedure works internally — only what it does (its API). This is the core concept: abstraction through libraries.
Random Values
In plain English: RANDOM(a, b) returns a random integer from a to b, inclusive. Used in simulations and games. Running the same program multiple times may produce different results.
Exam tests: Tracing code with RANDOM, identifying the range of possible outputs, understanding why simulations produce different results each run.
⚠ Trap:RANDOM(1, 6) simulates a die roll and can return 1, 2, 3, 4, 5, or 6. The exam asks what the possible outputs are — remember both endpoints are included.
Simulations
In plain English: Simulations model real-world processes using abstractions. They can test scenarios too expensive, dangerous, or slow to test in reality. Simulations involve trade-offs between accuracy and simplicity.
Exam tests: Identifying when a simulation is appropriate, understanding the limitations of simulations, knowing that simulations use random values for uncertainty.
⚠ Trap:Simulations are not perfect models. They make simplifying assumptions. The exam asks what a simulation can and cannot tell us — it can suggest likely outcomes but cannot guarantee real-world results.
Algorithm Efficiency
In plain English: Efficiency is measured by how an algorithm's runtime grows as input size increases. Reasonable time: grows polynomially (n, n², etc.). Unreasonable time: grows exponentially (2⊃n). Heuristic solutions approximate answers when exact solutions are too slow.
Exam tests: Classifying algorithms as reasonable or unreasonable time, understanding why some problems require heuristic solutions.
⚠ Trap:An exponential algorithm (2⊃n) becomes impossibly slow very quickly. For n=100, 2¹00; is astronomically large. The exam asks about scalability — does the algorithm remain practical as data grows?
Undecidable Problems
In plain English: Some problems cannot be solved by any algorithm for all possible inputs. The halting problem (will this program ever stop?) is the classic example. Undecidable does not mean the answer is unknown — it means no general algorithm can always find the answer.
Exam tests: Identifying undecidable problems, understanding what undecidable means, knowing the halting problem.
⚠ Trap:Undecidable problems can be solved for specific inputs but not for all inputs in general. The exam asks whether a problem is decidable — if an algorithm could theoretically always solve it, it is decidable.
Full reference: Big Idea 3 Study Guide
Big Idea 4: Computer Systems and Networks (CSN)
~11–15% of exam — the Internet, protocols, fault tolerance, parallel computingBig Idea 4 covers how the Internet works, how data moves between computers, and how systems are designed to handle failures. These questions tend to be conceptual rather than computational.
The Internet
In plain English: The Internet is a network of networks. Data travels in packets. IP addresses identify devices. DNS translates domain names to IP addresses. HTTP/HTTPS are protocols for web data. Routers direct packets.
Exam tests: Understanding how packets travel, what IP addresses and DNS do, the difference between HTTP and HTTPS, how routing works.
⚠ Trap:Data is broken into packets that may take different routes and arrive out of order — they are reassembled at the destination. The exam asks about this packet-switching model frequently.
Fault Tolerance
In plain English: Networks are designed so that if one path fails, data can still reach its destination via another route. Redundancy (multiple paths) enables fault tolerance. The Internet was designed to survive partial failures.
Exam tests: Identifying whether a network can still communicate if specific connections fail, understanding why redundancy is built into network design.
⚠ Trap:A network is fault tolerant if any two nodes can still communicate after a single connection failure. The exam gives you a network diagram and asks which connections, if removed, disconnect the network.
Parallel and Distributed Computing
In plain English: Parallel computing uses multiple processors simultaneously to solve a problem faster. Distributed computing uses multiple networked computers. Speedup is limited by the sequential portion of the task (Amdahl’s Law).
Exam tests: Calculating speedup from parallelization, understanding why not all problems can be fully parallelized, knowing what distributed computing enables.
⚠ Trap:If a task is 50% parallelizable, you cannot achieve more than 2x speedup no matter how many processors you add. The sequential portion is the bottleneck. The exam tests this concept with specific percentage calculations.
Full reference: Big Idea 4 Study Guide
Big Idea 5: Impact of Computing (IOC)
~22–30% of exam — beneficial and harmful effects, bias, privacy, security, ethicsBig Idea 5 is the second largest content area. It covers computing’s effects on society, ethics, and individuals. These questions require no coding knowledge but do require understanding real-world implications of technology decisions.
Beneficial and Harmful Effects
In plain English: Computing innovations have both intended and unintended consequences. Benefits include new capabilities, efficiency, and communication. Harms include privacy loss, job displacement, environmental impact, and new attack surfaces.
Exam tests: Identifying intended vs. unintended effects of a computing innovation, evaluating both benefits and harms of a specific technology.
⚠ Trap:The exam often describes a new technology and asks what an UNINTENDED effect might be. Unintended does not mean negative — but it does mean the developer did not plan for it.
Digital Divide
In plain English: The digital divide is the gap between those who have access to computing technology and those who do not. It exists across economic, geographic, age, and ability dimensions. Access affects economic and educational opportunity.
Exam tests: Identifying what causes the digital divide, understanding its consequences, recognizing policies that could reduce it.
⚠ Trap:The digital divide is not just about owning a device — it includes internet access speed, digital literacy, and language barriers. All are tested.
Computing Bias
In plain English: Algorithms and data sets can reflect and amplify human biases. Biased training data leads to biased AI decisions. Facial recognition, hiring algorithms, and loan approvals are common examples. Diverse development teams reduce but don’t eliminate bias.
Exam tests: Identifying how bias enters an algorithm, understanding why diverse teams help, evaluating whether a specific scenario represents computing bias.
⚠ Trap:Bias can be unintentional. If a training data set overrepresents one group, the model will perform worse on underrepresented groups — even if no one intended to discriminate.
Crowdsourcing
In plain English: Crowdsourcing uses contributions from many people to complete a task or gather data. Examples: Wikipedia, citizen science projects, open-source software, reCAPTCHA. The Internet enables large-scale crowdsourcing.
Exam tests: Identifying examples of crowdsourcing, understanding benefits (scale, diverse input) and limitations (accuracy, quality control).
⚠ Trap:Crowdsourcing can produce inaccurate results if contributors are misinformed or malicious. The exam asks both about the power of crowdsourcing AND its limitations.
Legal and Ethical Concerns
In plain English: Copyright protects original works. Creative Commons licenses allow sharing with conditions. Open-source software has publicly available source code. Plagiarism violates academic integrity. Computing innovations can outpace laws designed to regulate them.
Exam tests: Distinguishing copyright, Creative Commons, and open source. Identifying legal vs. ethical issues with specific computing scenarios.
⚠ Trap:Something can be legal but unethical, or ethical but illegal. The exam asks about both dimensions separately. Sharing copyrighted material without permission is illegal even if the sharer believes information should be free.
Safe Computing
In plain English: Cybersecurity threats include phishing, malware, ransomware, and social engineering. Strong passwords and multi-factor authentication reduce risk. Encryption protects data in transit and storage. PII (personally identifiable information) must be protected.
Exam tests: Identifying types of cybersecurity attacks, understanding how encryption works conceptually, knowing what constitutes PII and why it matters.
⚠ Trap:PII includes name, address, SSN, biometrics — any data that can identify a specific individual. Combining non-PII data sets can create PII (for example, combining ZIP code, birth date, and gender can uniquely identify most people).
Full reference: Big Idea 5 Study Guide
The Create Performance Task (30% of Your Score)
The Create Performance Task is a programming project you complete before exam day. It is submitted through the AP Digital Portfolio approximately 3 weeks before the exam. It is scored by College Board readers and counts for 30% of your AP score — as much as 21 MCQ questions combined.
Key deadline: The Create Task must be submitted through AP Digital Portfolio before the College Board deadline, typically in late April. Missing the deadline means a score of zero on 30% of your exam.
A short video (no longer than 1 minute, no larger than 30MB) showing your program running. Must show input to the program AND output produced by the program. No voice narration allowed. No identifying information about yourself.
The entire program code, submitted as a PDF. Collaboration is allowed on the program, but written responses must be your own individual work. The program must use at least one list and at least one student-developed procedure.
Four written responses totaling approximately 750 words. These describe your program's purpose, the function shown in the video, how your procedure works, and what would happen with a different call to your procedure. These are scored individually.
What the rubric scores: College Board scores 6 rows in the Create Task. Each row is worth 1 point for a total of 6 points (which maps to the 30% score weight). The rows cover: program purpose and function, data abstraction, managing complexity, procedural abstraction, algorithm implementation, and testing.
The AP CSP Pseudocode Reference — Every Instruction Explained
The AP exam provides a pseudocode reference sheet during the test. Unlike AP CSA, there is no specific programming language — all code on the exam uses this pseudocode. Here is every instruction type explained.
| Instruction | What It Does | Key Detail |
|---|---|---|
a ← expression |
Assigns the value of expression to variable a | This is assignment, not equality checking |
DISPLAY(expression) |
Shows the value of expression followed by a space | Similar to print() or System.out.println() |
INPUT() |
Gets a value from the user and returns it | Usually assigned: x ← INPUT()
|
a + b, a - b, a * b, a / b |
Standard arithmetic operators | Division always returns a decimal (not integer division) |
a MOD b |
Returns the remainder when a is divided by b | MOD 2 = 0 means even; MOD 2 = 1 means odd |
RANDOM(a, b) |
Returns a random integer from a to b, inclusive | Both endpoints can be returned |
a = b, a ≠ b, a > b, a < b |
Relational operators, return true or false | = checks equality here (not assignment like in Java) |
NOT condition |
True if condition is false, false if condition is true | Flips a boolean value |
condition1 AND condition2 |
True only if both conditions are true | Short-circuits: if first is false, second not evaluated |
condition1 OR condition2 |
True if at least one condition is true | Short-circuits: if first is true, second not evaluated |
IF (condition) { } |
Executes block only if condition is true | No action if condition is false and no ELSE |
IF (condition) { } ELSE { } |
First block if true, second block if false | Exactly one block always executes |
REPEAT n TIMES { } |
Executes block exactly n times | n must be a positive integer |
REPEAT UNTIL (condition) { } |
Repeats until condition becomes true | Runs at least once; condition checked after each iteration |
FOR EACH item IN list { } |
Iterates over each element in list | item takes each value in order; 1-based indexing |
list[i] |
Returns the element at index i (1-based) | First element is list[1], not list[0] |
INSERT(list, i, value) |
Inserts value at index i, shifts elements right | All elements from i onward move up one position |
APPEND(list, value) |
Adds value to the end of the list | Size increases by 1 |
REMOVE(list, i) |
Removes element at index i, shifts left | All elements after i move down one position |
LENGTH(list) |
Returns the number of elements in the list | Works on lists and strings |
PROCEDURE name(params) { } |
Defines a reusable block of code with parameters | Call with name(arguments) to execute |
RETURN(expression) |
Returns a value from a procedure | Execution returns to the caller |
Frequently Asked Questions
Official source: This page is based on the College Board AP CSP Course and Exam Description (PDF). Always verify against the official document for the most current information.
Where to Go From Here
- Daily Practice (QOTD) — Free daily CSP questions organized by Big Idea
- AP CSP Test Builder — Build a custom practice exam from 500+ questions
- Big Idea 1 Study Guide — Creative Development deep dive
- Big Idea 2 Study Guide — Data, binary, compression, privacy
- Big Idea 3 Study Guide — All AAP topics with pseudocode examples
- Big Idea 4 Study Guide — Internet, fault tolerance, parallel computing
- Big Idea 5 Study Guide — Ethics, privacy, bias, security
Get in Touch
Whether you're a student, parent, or teacher — I'd love to hear from you.
Just want free AP CS resources?
Enter your email below and check the subscribe box — no message needed. Students get daily practice questions and study tips. Teachers get curriculum resources and teaching strategies.
Message Sent!
Thanks for reaching out. I'll get back to you within 24 hours.
tanner@apcsexamprep.com
Courses
AP CSA, CSP, & Cybersecurity
Response Time
Within 24 hours
Prefer email? Reach me directly at tanner@apcsexamprep.com