AP CSP Topics
AP Computer Science Principles Topics (2025–2026)
Every AP CSP topic organized by the 5 Big Ideas — Creative Development, Data, Algorithms & Programming, Computing Systems & Networks, and Impact of Computing. Each card links to a complete study guide with practice questions, vocabulary, and exam tips. Also includes the AP pseudocode reference, Create Task scoring guide, most common mistakes, exam tips per Big Idea, and FAQ. Built by Tanner Crow — AP CS teacher at Blue Valley North High School, 11+ years, 54.5% of AP CSA students score 5s (national avg: 25.5%).
Quick Navigation
Big Idea 1: Creative Development
Big Idea 1 covers the process of creating programs: how software is designed, how teams collaborate to reduce errors and bias, how programs are tested and debugged, and what abstraction means at both the procedural and data level. BI1 questions on the MCQ section often describe a development scenario and ask which concept it represents, or ask you to identify an example of abstraction in a given program description.
Abstraction
Procedural abstraction (hiding implementation in a procedure) vs. data abstraction (organizing multiple values in a list or structure). Core to the Create Task rubric.
Program Design and Development
Iterative vs. incremental development. Requirements, prototyping, testing, and refinement. How programs are planned before code is written.
Collaboration in Computing
Working in teams reduces individual bias and blind spots. Pair programming, code review, and crowdsourcing as collaborative strategies. Why diverse teams produce better software.
Debugging: Syntax, Logic, and Runtime Errors
Syntax errors prevent execution. Logic errors produce wrong output. Runtime errors crash during execution. How to systematically isolate and fix each type.
Testing, Edge Cases, and Verification
Selecting test cases that reveal errors. Edge cases (boundary values, empty input, maximum input). Why testing can reveal bugs but cannot prove their absence.
Documentation and Code Readability
Why comments improve maintainability. The difference between useful comments (explain why) and useless ones (restate what the code already says).
Program Purpose vs. Program Function
Describing WHAT a program does (purpose) vs. HOW it does it (function). Tested directly on the Create Task written response prompt.
Sequencing, Selection, and Iteration
The three fundamental constructs of all programs. Every computable behavior can be expressed using these three. How AP exam questions combine all three in pseudocode traces.
Big Idea 2: Data
Big Idea 2 covers how computers represent, store, compress, and analyze data. Many students underestimate this Big Idea because individual topics seem simple, but the AP exam asks nuanced questions about compression trade-offs, the privacy implications of metadata, and the critical distinction between correlation and causation in data analysis. Students who miss BI2 questions almost always lose them to one of three topics: compression, metadata, or correlation vs. causation.
Binary Numbers and Digital Data Representation
All digital data stored as 0s and 1s. Adding one bit doubles possible values. RGB color encoding (3 bytes = 16.7M colors). Sound digitized by sampling analog waves at intervals.
Lossless vs. Lossy Compression
The #1 BI2 trap. Lossless (ZIP, PNG, FLAC) can perfectly reconstruct original data. Lossy (JPEG, MP3, MP4) permanently discards data for smaller file size and cannot be fully reversed.
Metadata and Privacy Implications
Data describing other data: timestamps, GPS, device info, file size. Metadata from phone calls (who, when, how long) can reveal private patterns even when call content is encrypted.
Data Collection, Sampling, and Bias
How data is gathered shapes what conclusions are possible. Biased samples, self-selection, and convenience sampling produce skewed datasets. Sample size affects reliability.
Cleaning and Filtering Data
Removing errors, duplicates, and irrelevant records from raw datasets. Why analysts must clean data before drawing conclusions. What “dirty data” does to results.
Correlation vs. Causation
Two variables moving together does not mean one causes the other. Confounding variables explain many apparent correlations. The AP exam frequently asks students to identify overclaimed conclusions.
Data Visualization and Pattern Recognition
Choosing chart types for different data relationships. How visual design can clarify or obscure trends. Common misleading visualization techniques (truncated y-axis, cherry-picked time ranges).
Overflow and Roundoff Errors
Overflow: computed value exceeds storage capacity, causing incorrect results. Roundoff: certain decimals cannot be represented exactly in binary (0.1 + 0.2 ≠ 0.3 in floating point).
Analog vs. Digital Data
Continuous real-world signals (sound, light, temperature) vs. discrete digital representations. Sampling rate and bit depth determine digital audio quality. Higher sampling = larger file.
Big Idea 3: Algorithms & Programming
Big Idea 3 is the most important and most challenging section of the AP CSP exam. With 30–40% of the total score, it contains more questions than any other Big Idea. Every BI3 question involves AP pseudocode — either reading and tracing existing code to determine output, identifying an error in a program, or writing pseudocode to accomplish a described task. Students who are not fluent in AP pseudocode syntax (particularly 1-indexed lists, REPEAT UNTIL, and FOR EACH) will struggle here regardless of their general programming ability.
AP Pseudocode Syntax Overview
The official exam language. Assignment uses ← not = or :=. Lists are 1-indexed. DISPLAY() for output. Not Java, not Python — a unique language you must learn specifically for this exam.
Variables and Assignment
How variables store and update values. Tracing assignment sequences step by step. The most common trap: forgetting that assignment replaces the previous value entirely.
Boolean Expressions and AND / OR / NOT
Truth tables for AND, OR, NOT. Evaluating compound Boolean expressions with specific variable values. Nested Boolean logic. De Morgan's Laws in AP pseudocode form.
Conditionals: IF / ELSE IF / ELSE
Decision structures in pseudocode. Nested conditionals. Determining which branch executes for a given input. Identifying the error that causes the wrong branch to run.
REPEAT N TIMES Loops
Fixed-iteration loops. Tracing to determine output or final variable value. Off-by-one analysis. When REPEAT N TIMES is the right choice vs. REPEAT UNTIL.
REPEAT UNTIL Loops
Condition-controlled iteration. Tracing to find when the exit condition becomes true. Infinite loop identification: exit condition that can never be met. Contrast with REPEAT N TIMES.
FOR EACH Loops and List Traversal
Iterating over every list element. Building results through traversal: sum, count, filter, find maximum. The standard traversal template in AP pseudocode.
Lists: 1-Indexing, Operations, and Mutations
1-indexed list access (list[1] = first element). LENGTH(list). APPEND(list, val). INSERT(list, i, val). REMOVE(list, i). Tracking how each operation changes list contents step by step.
Procedures, Parameters, and Return Values
Defining PROCEDURE name(params). Calling procedures with arguments. RETURN sends a value back. Procedural abstraction: caller knows WHAT a procedure does, not HOW it works.
Linear Search
Sequential scan of every element from first to last. Works on any list regardless of order. O(n): runtime grows linearly with list size. Returns index or signals not found.
Binary Search
Requires a SORTED list. Halves the search space each iteration. Much faster than linear search for large data. Common AP trap: applying binary search to an unsorted list.
Algorithmic Efficiency
Which algorithm is faster for large inputs? Efficiency matters when n = 1,000,000. Qualitative analysis: doubling the input doubles linear time but barely increases logarithmic time.
Heuristics and Good-Enough Solutions
When optimal solutions are computationally too expensive, a heuristic finds a good-enough answer faster. Navigation apps, scheduling, and recommendation systems all use heuristics.
Undecidable Problems and the Halting Problem
Some problems have no algorithm that always gives the correct yes/no answer for every input. The Halting Problem is the canonical example. This is mathematically proven — not a hardware limitation.
Big Idea 4: Computing Systems & Networks
Big Idea 4 is the smallest section of the AP CSP exam but is all conceptual vocabulary. Students who confuse related terms — TCP vs. IP, HTTP vs. HTTPS, internet vs. web, bandwidth vs. latency, parallel vs. sequential — miss the majority of these 8–11 questions. The fault tolerance network diagram question (trace paths after removing a connection) appears on almost every AP CSP exam and is worth dedicated practice.
The Internet: A Network of Networks
The global system of interconnected, independently operated networks using TCP/IP. No single entity owns it. Decentralized by design for resilience and openness.
Internet vs. World Wide Web
The most common BI4 vocab trap. Internet = the physical infrastructure (cables, routers, TCP/IP). Web = one application on top of it (HTTP, browsers, hyperlinks). Email and streaming are also internet but not web.
TCP/IP, HTTP, HTTPS, and DNS
IP: addressing and routing. TCP: reliable ordered delivery. HTTP: web page transfer. HTTPS: HTTP + TLS encryption. DNS: translates domain names to IP addresses.
Packet Switching
Data broken into addressed packets that route independently across a network and are reassembled at the destination. More efficient and fault tolerant than circuit switching (dedicated path).
Fault Tolerance and Network Redundancy
A fault tolerant network keeps working when connections fail. Redundant paths allow rerouting. AP exam strategy: trace all paths between two nodes after removing the specified connection.
Parallel vs. Sequential Computing
Sequential = one step at a time. Parallel = multiple processors simultaneously. Parallel reduces wall-clock time but NOT total work. Sequential dependencies set a hard lower bound on speed regardless of processor count.
Encryption: Symmetric and Asymmetric
Symmetric: same key for encryption and decryption (fast, requires key sharing). Asymmetric: public key encrypts, private key decrypts (solves the key distribution problem). HTTPS uses both.
Bandwidth and Latency
Bandwidth = capacity (how much data per second). Latency = delay (how long until first response). Satellite internet: high bandwidth, high latency. Fiber: high bandwidth, low latency. Both matter differently.
Big Idea 5: Impact of Computing
Big Idea 5 covers the social, ethical, and legal dimensions of computing. It is the second-largest section and is entirely conceptual — no pseudocode, no algorithms. Students who dismiss BI5 as the “easy” Big Idea often lose points because the questions require careful reasoning, not just recall. The copyright/Creative Commons/open source distinction, the specific mechanisms of algorithmic bias, and the nuances of the digital divide are each tested with precision that requires studying the exact vocabulary.
Privacy, Personal Data, and PII
What counts as personally identifiable information (PII). How digital activity creates permanent data trails. Why metadata exposes private patterns even when content is encrypted.
Digital Divide
The technology access gap across economic, geographic, demographic, and disability lines. Causes, consequences, and why tech solutions can accidentally widen the divide they intend to close.
Algorithmic Bias and Fairness
Biased training data produces biased algorithmic outcomes — even in well-intentioned systems. Feedback loops amplify existing bias. Diverse teams reduce (but cannot eliminate) algorithmic bias.
Copyright and Intellectual Property
Automatic protection for original creative works. What copyright covers (expression) and doesn't cover (ideas, facts). Fair use basics. How copyright applies to code, music, and online content.
Creative Commons and Open Source Licensing
Creative Commons licenses allow sharing with specific user-defined conditions (attribution, non-commercial, no derivatives). Open source makes source code publicly available. Neither means unrestricted use.
Crowdsourcing and Citizen Science
Distributing tasks or data collection to large online groups. Wikipedia, OpenStreetMap, protein folding research, and Amazon Mechanical Turk. Benefits (scale), challenges (quality control, data integrity).
Filter Bubbles and Recommendation Algorithms
Personalization algorithms show users content matching their existing preferences, creating intellectual isolation. Political polarization, echo chambers, and the erosion of shared information environment.
Cybersecurity, Phishing, and Social Engineering
Why humans are the weakest link in security. Phishing (fake emails/sites), vishing (phone calls), pretexting (fabricated scenarios). Defense: MFA, skepticism, verification protocols.
Unintended Consequences of Computing Innovations
Technologies designed to help can cause unexpected harm. Surveillance, automation job displacement, misinformation amplification. How to identify unintended consequences in AP exam scenarios.
Computing and Environmental Impact
Energy consumption of data centers, AI training, and cryptocurrency mining. E-waste from rapid device obsolescence. Carbon footprint trade-offs of streaming video. Sustainability considerations.
AP Pseudocode Quick Reference
These are the exact pseudocode constructs that appear on the AP CSP exam. Every BI3 question uses this syntax. AP pseudocode is not Java, not Python — it has its own rules that you must learn specifically. The most critical difference: lists are 1-indexed (the first element is at index 1, not 0).
| Construct | AP Pseudocode Syntax | What It Does / Key Exam Notes |
|---|---|---|
| Assignment | x ← 5 / x ← x + 1 | Replaces the old value of x. Trace carefully: after x←3, x←x+1, x equals 4 — not 3+1=4 but the stored value is now 4. |
| Display output | DISPLAY(expression) | Prints the value of expression. DISPLAY(x) prints the current value of x. |
| User input | INPUT() | Receives a value from the user. Usually assigned: x ← INPUT() |
| Arithmetic | + - * / MOD | MOD returns the remainder: 17 MOD 5 = 2. Integer division: 7 / 2 = 3.5 in AP pseudocode (not truncated like Java). |
| Comparison | = ≠ < > ≤ ≥ | Used in conditions. Note: = is comparison in AP pseudocode, not assignment (assignment uses ←). |
| Boolean AND | condition1 AND condition2 | TRUE only if both conditions are TRUE. Short-circuits: if first is FALSE, second is not evaluated. |
| Boolean OR | condition1 OR condition2 | TRUE if at least one condition is TRUE. Short-circuits: if first is TRUE, second is not evaluated. |
| Boolean NOT | NOT condition | Reverses truth value. NOT TRUE = FALSE. NOT (x > 5) = (x ≤ 5). |
| IF statement | IF (condition) { block } | Executes block only if condition is TRUE. Block is skipped entirely if FALSE. |
| IF / ELSE | IF (cond) { } ELSE { } | Exactly one of the two blocks executes. ELSE runs when condition is FALSE. |
| REPEAT N TIMES | REPEAT n TIMES { block } | Executes block exactly n times. n is evaluated once at the start — changing n inside the loop does not affect iteration count. |
| REPEAT UNTIL | REPEAT UNTIL (condition) { block } | Executes block repeatedly until condition becomes TRUE. Condition is checked AFTER each execution (always runs at least once). |
| FOR EACH | FOR EACH item IN list { block } | item takes the value of each list element in order. item is a temporary variable — modifying it does NOT modify the list. |
| List access | list[i] | Returns element at index i. LISTS ARE 1-INDEXED. list[1] = first element. list[LENGTH(list)] = last element. list[0] does not exist. |
| LENGTH(list) | LENGTH(list) | Returns the number of elements. Use list[LENGTH(list)] for the last element. |
| APPEND(list, val) | APPEND(myList, 7) | Adds val to the END of the list. List length increases by 1. |
| INSERT(list, i, val) | INSERT(myList, 2, 7) | Inserts val at index i. All elements at i and beyond shift right. List length increases by 1. |
| REMOVE(list, i) | REMOVE(myList, 2) | Removes the element at index i. All elements beyond i shift left. List length decreases by 1. |
| PROCEDURE definition | PROCEDURE name(param1, param2) { block } | Defines a reusable procedure. Parameters receive argument values at call time. Parameters are local — changes do not affect variables outside. |
| RETURN | RETURN expression | Sends a value back to the caller and exits the procedure immediately. Procedures without RETURN are void-equivalent. |
| PROCEDURE call | name(arg1, arg2) / x ← name(arg1) | Executes the procedure with given arguments. If the procedure returns a value, capture it with assignment. |
| Robot: MOVE_FORWARD | MOVE_FORWARD() | Moves the robot one square in the direction it is currently facing. Error if blocked by a wall. |
| Robot: ROTATE_LEFT / RIGHT | ROTATE_LEFT() / ROTATE_RIGHT() | Turns the robot 90 degrees left or right. Does not move forward. |
| Robot: CAN_MOVE | CAN_MOVE(direction) | Returns TRUE if robot can move in the given direction (forward, backward, left, right) without hitting a wall. |
For a printable 2-page version: AP CSP Pseudocode Reference Sheet →
Create Task Scoring Guide — How All 6 Points Are Earned
The AP CSP Create Task is scored by College Board readers on a 6-point rubric. Each point has a specific, precise requirement. Students who understand exactly what each row of the rubric requires — and what disqualifies a response — earn significantly more points than those who write generally about their program.
| Pts | Row | Exactly What You Must Demonstrate | Most Common Way to Lose This Point |
|---|---|---|---|
| 1 pt | Program Purpose and Function | Describe the overall purpose of the program AND what the program does AND what input/output the video shows. All three must be present. | Describing what the program does without stating its purpose (why someone would use it). These are different: purpose = why it exists; function = what it does. |
| 1 pt | Data Abstraction — Code | Show a list (or other collection) being created AND the same list being used to store or process multiple pieces of data that help fulfill the program's purpose. | Using a list that is trivially populated (e.g., manually typed out) and never actually needed — a list that could be replaced with individual variables without changing the program. |
| 1 pt | Data Abstraction — Written Response | Identify the name of the list AND describe what the data in the list represents AND explain why the list was necessary to manage complexity. | Describing what individual elements contain without explaining how storing them in a list helps the program manage complexity beyond what individual variables could achieve. |
| 1 pt | Managing Complexity | Show how the list manages complexity by allowing the program to work without knowing in advance how many items will be processed, or by enabling iteration that would be impossible with individual variables. | This is the most-missed point. Students use a list but describe it as just storage rather than explaining why a list was structurally necessary for the program to function as designed. |
| 1 pt | Procedural Abstraction — Code | Define a procedure with at least one parameter that affects the functionality of the procedure. The procedure must be called in the program. | Defining a procedure that takes a parameter but the parameter does not actually change what the procedure does — e.g., a parameter passed in but never used in the body. |
| 1 pt | Procedural Abstraction — Written Response | Explain what the procedure does AND describe how the specific algorithm inside it works AND explain how it contributes to the overall program's functionality. | Describing what the procedure does without explaining the specific algorithm steps inside it. Readers need to understand the logic, not just the output. |
For fully worked examples with annotated responses: Create Task Complete Guide → • Written Response Scoring Guide (3 full projects) →
Exam Tips — One Critical Insight Per Big Idea
These are the single highest-value things to know for each Big Idea based on released exam analysis and 11+ years of AP CS classroom data.
Create Task Vocabulary = MCQ Vocabulary
The words “abstraction,” “managing complexity,” and “procedural abstraction” appear on both the Create Task rubric and the MCQ. Students who understand what these terms mean deeply — not just how to use them — answer BI1 MCQs faster and more accurately.
Lossless vs. Lossy: One Sentence That Earns Points
Lossless can be perfectly reversed to the original. Lossy cannot. Memorize one example of each: PNG and ZIP are lossless. JPEG and MP3 are lossy. Every BI2 compression question reduces to this distinction.
AP Lists Start at Index 1, Not 0
This is the single most common pseudocode trap. In Java and Python, list[0] is the first element. In AP pseudocode, list[1] is the first element. A question that asks what list[1] returns after inserting at position 1 requires you to know this cold.
Fault Tolerance: Count Paths, Not Connections
When a network diagram question removes a connection, students who count remaining connections get it wrong. Students who trace complete paths from one node to another get it right. Always ask: is there ANY remaining path from A to B?
Copyright, Creative Commons, Open Source: Three Different Things
Copyright = automatic protection, all rights reserved by default. Creative Commons = creator chooses specific permissions. Open source = source code is publicly available but may still have license conditions. These are frequently conflated; the AP exam tests the distinctions precisely.
Common AP CSP Mistakes That Cost Points
These are the specific errors that appear most frequently when analyzing AP CSP exam results. Each has been observed across hundreds of student responses and practice exam reviews.
1-Indexed List Confusion
Wrong: list[0] is the first element
Right: list[1] is the first element in AP pseudocode. This is different from every mainstream programming language and appears on multiple BI3 questions every year.
Applying Binary Search to Unsorted Data
Wrong: Binary search works on any list
Right: Binary search ONLY works on sorted lists. Applying it to unsorted data produces incorrect results. Always check: is the list sorted before choosing binary search?
Treating REPEAT UNTIL as REPEAT WHILE
Wrong: REPEAT UNTIL runs while condition is FALSE
Right: REPEAT UNTIL continues until the condition becomes TRUE — it stops when TRUE, not when FALSE. This is the opposite of a WHILE loop.
Lossless vs. Lossy Reversal
Wrong: Lossy compression can be reversed to get the original file back
Right: Lossy compression permanently removes data. It cannot be perfectly reversed. Only lossless compression (ZIP, PNG, FLAC) allows perfect reconstruction.
Internet vs. World Wide Web
Wrong: The internet and the web are the same thing
Right: The internet is the global network infrastructure. The web is one application on top of it. Email, streaming, and gaming also use the internet but are not the web.
Parallel Computing Eliminates All Sequential Steps
Wrong: Adding more processors always makes programs faster
Right: Tasks with sequential dependencies cannot be parallelized. If Step B requires Step A's output, no number of processors can make them run simultaneously.
Correlation Implies Causation
Wrong: If two variables are correlated, one causes the other
Right: Correlation only means two variables move together. A third confounding variable often explains both. The AP exam specifically tests this on data analysis questions.
Describing Purpose vs. Function
Wrong: Program purpose and program function are the same thing
Right: Purpose = WHY the program exists (the problem it solves). Function = WHAT it does mechanically. The Create Task rubric requires both and scores them separately.
FOR EACH Modifies the List
Wrong: Assigning to the loop variable inside FOR EACH changes the list
Right: The loop variable in FOR EACH is a temporary copy. Changing it does NOT modify the original list. To modify a list while iterating, you need an index-based loop.
Encryption Makes Data Anonymous
Wrong: Encrypting data prevents anyone from knowing what you sent
Right: Encryption hides content but not metadata. Encrypted traffic still reveals who you communicated with, when, and how much data was transferred.
Create Task and Written Response Practice
The Create Task counts as part of your AP score and is submitted before the exam. The written response — where you answer questions about your own code — is completed on exam day. Students who practice writing rubric-aligned responses before exam day consistently earn more points than those who encounter the prompts for the first time on the exam.
Targeted Practice Sets
Full interactive practice sets for the question types that appear most often on the AP CSP exam. Each set includes predict-first design, detailed explanations, and score tracking.
Robot Tracing Practice
14 interactive questions covering all 6 robot question styles: path tracing, spot the error, I/II/III format, CAN_MOVE loops, procedure calls, drawing devices, and MISSING CODE maze questions with black obstacle squares.
Filtering, Sorting & Boolean Expressions
10 questions across 3 types: writing AND/OR boolean filter conditions, determining which filter/sort step sequence produces the correct result, and algorithm step ordering with dependency constraints.
Data Analysis: CAN/CANNOT & Metadata
10 questions on the two most common Big Idea 2 exam types: determining what can and cannot be found from a dataset, and deciding whether data or metadata is the right source for a given analysis goal.
AP CSP Study Tools & Products
Full Practice Exam — 70 MCQ
Complete timed practice test. All 5 Big Ideas weighted to match the real exam. Full answer explanations.
Quick Reference Guide — 5 Big Ideas
17-page flagship reference. Every term, concept, and pseudocode pattern organized for fast lookup.
Vocabulary List — 145 Terms
All 5 Big Ideas, exam-aligned definitions, color-coded by Big Idea. Includes Big Idea 3 terms tested in code questions.
Pseudocode Reference Sheet
Every AP pseudocode command on 2 pages. 1-indexed list operations, robot commands, procedure syntax.
Create Task Guide — Score 6/6
Rubric-aligned with annotated examples. The managing complexity point explained in full detail.
Written Response Scoring Guide
3 fully worked projects with all prompts answered. Line-by-line annotation of what earns each point.
Complete Study Bundle — 6 Products
Everything above in one bundle. Best value for full exam prep coverage.
Frequently Asked Questions About AP CSP Topics
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.
Prefer email? Reach me directly at [email protected]