Free study guide — no login required
AP Computer Science Principles Study Guide (2026)
Last reviewed: 2026-06-10
AP Computer Science Principles is the College Board's introduction to computing as a discipline, not just a programming class. The course is organized around five Big Ideas — Creative Development, Data, Algorithms and Programming, Computing Systems and Networks, and Impact of Computing — and it deliberately stays language-agnostic. On the exam, all code appears in College Board's own text-based and block-based pseudocode, so a student who learned Python, JavaScript, or Scratch in class reads the same exam reference sheet as everyone else.
The assessment has two parts. The end-of-course exam is a two-hour, 70-question multiple-choice test that includes single-select questions, reading-passage questions about a computing innovation, and multiple-select questions where exactly two answers are correct. The other component is the Create Performance Task, a program you design and build during at least nine hours of class time, plus written responses about that program answered during the exam itself.
This guide walks through each Big Idea with its official exam weighting, the concepts the multiple-choice section actually tests — binary, compression, pseudocode tracing, the Internet protocol stack, digital divide — and a study plan built on retrieval practice and spaced repetition rather than passive rereading.
AP Computer Science Principles Exam Format
The AP Computer Science Principles exam is 3 hrs 15 min long and has 3 sections:
| Section | Format |
|---|---|
| Section I-A | 30 MCQs, no calculator (60 min) |
| Section I-B | 15 MCQs, calculator (45 min) |
| Section II | 6 FRQs (90 min) |
Your AP score blends two components: the Create Performance Task (worth 30%) and the end-of-course exam (worth 70%), combined into a composite reported on the 1-5 scale. The multiple-choice section gives you about 103 seconds per question, which is generous — most students who miss points lose them to careless pseudocode tracing, not time pressure. Memorize the exam reference sheet before test day: know that MOD returns remainders, that RANDOM(a, b) is inclusive on both ends, and that list indices start at 1, not 0.
Triage by question type. The 8 multiple-select questions require exactly two correct answers with no partial credit, so slow down on those. For robot-grid questions, physically sketch the grid and walk the turns. For reading-passage questions about a computing innovation, the answer is almost always stated in the passage — do not import outside assumptions. For the Create Task written responses, rehearse explaining your procedure's parameters, your list's purpose, and your two test calls before exam day.
Who Should Take AP Computer Science Principles?
AP CSP is the most accessible AP in the computer science family and one of the most accessible APs overall, with no programming prerequisite — algebra-level math is enough. It suits students who want to test whether computing interests them before committing to AP Computer Science A, as well as future non-majors who want a tech credential. Many colleges award elective or introductory computing credit for a 3 or higher, though selective CS programs typically grant credit only for CSA. The workload is moderate: the hardest stretch is the Create Performance Task, which rewards starting early. If you can trace simple loops and reason carefully about word problems, a 4 or 5 is very reachable.
AP Computer Science Principles Units: What to Study
Unit 1: Creative Development
10-13% of examCreative Development covers how programs get made: collaboration, iterative design, and program documentation. You need the vocabulary of the development process — investigating user needs, prototyping, testing, and the difference between iterative and incremental development. The exam tests error categories precisely: syntax errors (code violates language rules), logic errors (program runs but produces wrong output), run-time errors (crashes during execution), and overflow errors (a number exceeds what the computer can represent). Expect questions on debugging strategies like hand-tracing, adding extra output statements, and testing with edge-case inputs. This Big Idea also underpins the Create Performance Task: program purpose versus function, the value of comments and documentation, and how pair programming and diverse teams reduce bias and catch defects earlier. It is short, definitional, and a reliable source of quick points.
Key topics
- Iterative vs incremental development
- Syntax, logic, run-time, overflow errors
- Debugging and hand-tracing
- Program purpose vs program function
- Collaboration and pair programming
- Comments and documentation
- User-centered design and prototyping
Unit 2: Data
17-22% of examThe Data Big Idea starts with binary: converting between binary and decimal, understanding that n bits represent 2^n values, and recognizing why fixed-width integers cause overflow and why floating-point numbers produce round-off errors. Abstraction appears as the idea that the same bits can represent numbers, text, colors, or sound depending on interpretation. Compression is heavily tested — lossless (every bit recoverable, like run-length encoding) versus lossy (smaller files, irreversible quality loss) and when each is appropriate. The rest of the unit is data science in miniature: metadata versus data, cleaning datasets, bias introduced during collection, correlation versus causation, and why scalability pushes large datasets toward parallel processing. Expect chart-reading questions where you must identify what a dataset can and cannot support as a conclusion.
Key topics
- Binary-decimal conversion
- Bits, bytes, and 2^n values
- Overflow and round-off errors
- Lossless vs lossy compression
- Metadata
- Data bias and cleaning
- Correlation vs causation
- Extracting insight from large datasets
Unit 3: Algorithms and Programming
30-35% of examThis is the largest Big Idea by far, and it is tested almost entirely in College Board pseudocode. You must fluently trace code using sequencing, selection (IF/ELSE), and iteration (REPEAT n TIMES, REPEAT UNTIL), evaluate Boolean expressions with AND, OR, and NOT, and manipulate lists — remembering that indices start at 1. Procedures with parameters and return values test procedural abstraction; FOR EACH loops test list traversal patterns like summing, counting, and finding a maximum. Conceptual questions cover linear versus binary search (binary requires sorted data), reasonable versus unreasonable running time (polynomial versus exponential), heuristics for problems too expensive to solve exactly, undecidable problems like the halting problem, simulations as simplified models, and random number generation with RANDOM(a, b). Robot-on-a-grid questions using MOVE_FORWARD and ROTATE_LEFT appear every year.
Key topics
- College Board pseudocode tracing
- Selection and iteration structures
- Lists and 1-based indexing
- Procedures, parameters, return values
- Linear vs binary search
- Reasonable time: polynomial vs exponential
- Heuristics and undecidable problems
- Simulations and RANDOM(a, b)
Unit 4: Computing Systems and Networks
11-15% of examThis Big Idea explains how the Internet actually works. The exam expects you to know the layered roles of core protocols: IP addresses uniquely identify devices, the domain name system (DNS) translates names like maxyourscore.com into IP addresses, TCP guarantees ordered, complete delivery while UDP trades reliability for speed, and HTTP rides on top for the web. Data travels as packets that may take different routes and arrive out of order — that's why the Internet is fault tolerant: redundant paths mean the network keeps working when connections fail. Distinguish the Internet (the network) from the World Wide Web (a service on it), and bandwidth as a measure of capacity. The unit closes with computing models: sequential versus parallel versus distributed computing, including computing speedup and why a parallel solution is limited by its sequential portion.
Key topics
- IP addresses and routing
- DNS name resolution
- TCP/UDP and packets
- Redundancy and fault tolerance
- Internet vs World Wide Web
- Bandwidth
- Sequential, parallel, distributed computing
- Computing speedup
Unit 5: Impact of Computing
21-26% of examImpact of Computing is the second-heaviest Big Idea and the easiest to underestimate. It examines computing's benefits and harms: the digital divide (unequal access by geography, income, and infrastructure), algorithmic bias baked into training data, and the difference between intended use and unintended consequences of innovations. Crowdsourcing and citizen science show distributed human effort; legal topics include intellectual property, Creative Commons licensing, open source, and plagiarism. Security and privacy get serious coverage: personally identifiable information (PII), phishing, keylogging, malware, rogue access points, strong authentication including multifactor authentication, and encryption — know that symmetric encryption uses one shared key while public key (asymmetric) encryption uses a public/private key pair. Many questions here are passage-based judgment calls, so practice identifying the most defensible answer, not just a plausible one.
Key topics
- Digital divide
- Algorithmic bias
- Crowdsourcing and citizen science
- Creative Commons and open source
- PII and phishing
- Symmetric vs public key encryption
- Multifactor authentication
- Unintended consequences of innovation
How to Study for AP Computer Science Principles
Sequence your review around weight. Big Idea 3 (Algorithms and Programming) is 30-35% of the multiple-choice section, so pseudocode fluency is the highest-leverage skill you can build: trace ten short programs a day until REPEAT UNTIL conditions, nested IFs, and 1-based list indexing feel automatic. Pair it with Big Idea 5 (21-26%) and Big Idea 2 (17-22%) next, since together those three cover roughly three-quarters of the exam. Save Creative Development and Computing Systems for the final pass — they are short, definitional, and quick to lock in.
Study with retrieval practice, not rereading. After each topic, close the notes and write out the distinctions from memory: lossless versus lossy, TCP versus UDP, symmetric versus public key, linear versus binary search, syntax versus logic versus overflow errors. CSP rewards exactly this kind of paired-concept recall. Then schedule reviews with SM-2 spaced repetition — miss a card on DNS resolution and it returns tomorrow; nail it repeatedly and it stretches to weeks. MaxYourScore's unit quizzes feed this loop directly, resurfacing the questions you miss at expanding intervals.
On timeline: if the exam is two to three months out, finish the Create Performance Task first — it is 30% of your score and cannot be crammed, and you will answer written-response questions about your own program on exam day, so keep your code and design decisions fresh. The final month belongs to full-length 70-question practice sets under the real two-hour clock. In the last week, drill the exam reference sheet and the multiple-select question format, where choosing exactly two answers punishes half-remembered concepts.
AP Computer Science Principles FAQ
Is AP Computer Science Principles hard?
It is widely considered one of the more approachable AP courses. There is no programming prerequisite, the math stays at an algebra level, and all exam code uses College Board's pseudocode with a provided reference sheet. The challenges are vocabulary precision — distinguishing lossy from lossless or TCP from UDP — and the Create Performance Task, which demands sustained project work rather than test-taking skill.
What is the difference between AP Computer Science Principles and AP Computer Science A?
CSP is a breadth-first survey of computing: data, the Internet, societal impact, and basic programming in language-agnostic pseudocode, assessed by multiple choice plus a project. CSA is a depth-first programming course taught entirely in Java, covering object-oriented design, arrays, ArrayLists, inheritance, and recursion, with free-response questions requiring you to write working Java code. Many students take CSP first, then CSA.
How is the AP CSP exam scored?
Your score combines two components into a composite reported on the standard 1-5 scale. The end-of-course exam — 70 multiple-choice questions over two hours — counts for 70%. The Create Performance Task counts for 30%; you build the program during at least nine hours of class time, submit it with a video, and answer written-response questions about it during the exam itself. There is no penalty for guessing on multiple choice.
What is the Create Performance Task in AP CSP?
It is a programming project you complete during class before the exam window. You design a program containing a list (or other collection type), a student-developed procedure with a parameter that uses selection and iteration, and a call to that procedure. You submit the code and a video demonstrating it running. On exam day, you then answer written-response questions analyzing your own program, so know your code thoroughly.
Do colleges accept AP Computer Science Principles for credit?
Many colleges grant elective or general-education credit for a 3, 4, or 5, and some award credit for an introductory computing course. However, selective computer science programs often reserve CS-major credit for AP Computer Science A instead. Check each college's AP credit policy directly, since policies vary widely. Even without credit, CSP signals STEM readiness on applications and satisfies some states' computer science graduation requirements.
Ready to master AP Computer Science Principles?
Get all 5 unit videos, note packets, 100 quiz questions, 5 full-length practice exams, and a 24/7 Socratic AI tutor — $7.99/month with a 3-day free trial.