AP Computer Science Principles Exam Guide and Review
AP Computer Science Principles · May 2027AP Computer Science Principles Exam Guide and Review
- 62-page guide
- 5 Big Ideas
- 3-hour end-of-course exam
- 70 MCQ · 2 written-response questions
AP Computer Science Principles rewards exact tracing and evidence-based explanation. This review starts with the exam reference sheet and program state, then moves through data representation, algorithms, computer systems, networks, computing impacts, and the evidence students prepare for the Create Performance Task.
- Trace before explaining. Record initial state, legal list positions, branch outcomes, and every update before naming the final result.
- Connect claims to mechanisms. Explain how a procedure, representation, protocol, data choice, or design decision produces the stated effect.
- Test the edges. Use empty collections, first and last legal positions, absent targets, and exact comparison endpoints to expose defects.
- Keep Create evidence consistent. The program, video, Personalized Project Reference, and written responses must describe the same behavior.
Review the assessed ideas in their published order
AP Computer Science Principles reports content ranges by Big Idea, not by course unit. Each range below is a share of the multiple-choice section; it is not a share of the whole score, a promised question count, or the 30% assigned to the Create Performance Task and its written responses. The ranges are stated as of 2026-08-29.
Three hours of testing plus the course Create work
The course does not have a separate free-response section. The score comes from the multiple-choice section plus the course Create Performance Task and its two end-of-course written-response questions.
At a glance. End-of-course exam — 3 hours. Multiple choice — 70 questions · 120 minutes · 70% of the exam score. Create performance task and written response — 2 written-response questions · 60 minutes · 30% of the exam score · minimum 9 in-class hours for the task.
| Assessment part | Questions or evidence | Time | Score weight | Format |
|---|---|---|---|---|
| Multiple choice | 70 questions | 120 minutes | 70% of the exam score | 57 single-select; 5 passage-based single-select; 8 multi-select questions with two answers each |
| Create Performance Task | Program code, video, and Personalized Project Reference | Minimum 9 in-class hours | Part of Section II’s 30% | Course work developed by the student |
| Written responses | 2 questions containing 4 prompts | 60 minutes | Part of Section II’s 30% | Responses use the student’s Personalized Project Reference |
| End-of-course exam | 70 multiple-choice questions and 2 written-response questions | 3 hours | Section I 70% · Section II 30% | Fully digital in Bluebook |
The two written-response questions contain four prompts: Program Design, Function, and Purpose; Algorithm Development; Errors and Testing; and Data and Procedural Abstraction. The submitted Create components are program code, a video, and a Personalized Project Reference.
Check the official AP Computer Science Principles exam page and the current course and exam description for later changes. These details are stated as of 2026-08-29.
Trace a list-processing procedure before explaining it
This example uses the book’s complete Question → Trace and calculation → Answer and justification pattern, followed by boundary checks and a four-column scoring review.
- Step 1State what each variable represents before tracing updates.
- Step 2Follow the list in order and record only state-changing instructions.
- Step 3Summarize the relationship between the condition and the final result.
- Step 4Explain the effect of a proposed change using the same input-output relationship.
def prioritize_features(votes, capacity):
ranked = sorted(votes, key=votes.get, reverse=True)
chosen = []
for feature in ranked:
if len(chosen) < capacity and votes[feature] >= 2:
chosen.append(feature)
return chosen
def main():
votes = {"timer": 3, "themes": 1, "reminders": 4}
print(prioritize_features(votes, 2))
if __name__ == "__main__":
main()| Line | Intent |
|---|---|
| 1 | Declare the student-developed procedure and its two inputs. |
| 2–3 | Order feature names by vote count and start a separate result list. |
| 4–6 | Visit each feature, require capacity and threshold, and append accepted names. |
| 7 | Return the completed result after the traversal. |
| 8–10 | Open the demonstration, create the feedback data, and display the procedure result. |
| 11–12 | Run and call the demonstration only when this file is executed directly. |
| Trace step | State or decision |
|---|---|
| 1 | Sorting by vote count gives reminders 4, timer 3, themes 1. |
| 2 | Reminders passes 0 < 2 and 4 >= 2, so chosen becomes [reminders]. |
| 3 | Timer passes 1 < 2 and 3 >= 2, so chosen becomes [reminders, timer]. |
| 4 | Themes fails because capacity is already full and its vote count is below 2. |
| Case or error | Expected behavior or repair |
|---|---|
| Empty collection | The loop runs zero times and returns an empty list. |
| Off-by-one | Use len(chosen) < capacity; <= can admit a third feature once length equals 2. |
| Reference versus value | sorted creates a new name list; the procedure reads votes without changing its entries. |
| Rubric point | Model element | Common error | Credit |
|---|---|---|---|
| Program design and purpose | Feedback values control a visible feature-selection result | Names users or features without explaining the behavior | Practice evidence present |
| Procedure and call | A student-developed procedure is called with compatible arguments | Uses only a built-in action or mismatched call | Practice evidence present |
| Algorithm development | Iteration and selection build the bounded result | Describes the whole app instead of the selected algorithm | Practice evidence present |
| Output evidence | The displayed list matches the traced execution | Claims output not produced by the run | Practice evidence present |
Final check. Connect the votes to the branch decisions and the returned list.
Fourteen terms to use precisely
These terms are taught across the five Big Idea lessons and reviewed with related ideas in Appendix B. Attach each definition to a program state, representation, network behavior, test, or computing effect so it performs a clear job in your explanation.
- abstraction
- A representation that hides unnecessary detail while preserving useful behavior.
- algorithm
- A finite sequence of instructions designed to accomplish a task.
- program
- Instructions written so a computing device can perform a task.
- variable
- A name associated with a value that a program can use or change.
- list
- A collection that stores related values in a defined order.
- procedure
- A named group of instructions that performs a task.
- parameter
- A named input used by a procedure.
- Boolean expression
- An expression that evaluates as true or false.
- data abstraction
- A way to manage data through a representation that reduces detail.
- lossless compression
- Compression that permits exact reconstruction of the original data.
- lossy compression
- Compression that removes some data to reduce size.
- computing innovation
- A product or concept that includes a computing component.
- protocol
- An agreed set of rules for exchanging information.
- cybersecurity
- Practices that protect systems, networks, and data from harm or unauthorized access.
What to expect and how to use this guide
How is the AP Computer Science Principles exam organized?
The end-of-course exam lasts 3 hours. It includes 70 multiple-choice questions in 120 minutes and 2 written-response questions in 60 minutes. Multiple choice contributes 70%; the Create performance task and its written response contribute 30%.
What must I complete for the Create performance task?
You receive a minimum of 9 in-class hours to develop your program. The submitted components are program code, a video, and a Personalized Project Reference.
Is there a separate free-response section?
No. AP Computer Science Principles has no separate free-response section. Your score comes from the multiple-choice section plus the course Create Performance Task and its two end-of-course written-response questions.
What types of multiple-choice questions appear?
Of the 70 multiple-choice questions, 57 are single-select, 5 are single-select questions tied to a reading passage, and 8 are multi-select. Each multi-select question asks you to choose 2 answers.
How many Big Ideas organize AP Computer Science Principles?
The course is organized around five Big Ideas: Creative Development, Data, Algorithms and Programming, Computer Systems and Networks, and Impact of Computing.
How should I prepare for the written responses?
Know your own program and Personalized Project Reference well. Practice explaining purpose, algorithm behavior, data use, testing, and how a code change would affect the result.
Are official multiple-choice questions included in the publicly available materials?
No. The publicly available materials used for this guide contain no officially released AP Computer Science Principles multiple-choice questions. The practice questions in this guide were independently written for instruction.
Use four passes to turn code and evidence into scored reasoning
Pass 1 — read the notation and record state. Keep the AP CSP Exam Reference Sheet beside you while practicing. For every trace, write the initial values, the sheet’s one-based list positions, the stopping condition, and the exact statement that changes state. Treat assignment, equality, selection, and iteration as different operations. A correct final value without the controlling path will not repair a misconception.
Pass 2 — rebuild complete examples. Reproduce a program or scenario from question to trace to answer. For code, explain what each line contributes, run the supplied input, and test an empty or endpoint case. For data, networks, and computing impacts, identify the representation, mechanism, affected group, and limit of the claim. Then use the four-column check: requested point, model element, common error, and evidence needed.
Pass 3 — keep Create evidence consistent. Follow one program behavior across the final code, video, Personalized Project Reference, and response practice. Confirm that the chosen procedure has a behavior-changing parameter, includes sequencing, selection, and iteration, and is shown with a compatible call. Confirm that the chosen list is shown where it stores multiple values and where the same collection helps manage complexity. Test the exact version represented in every item.
Pass 4 — practice the real timing and formats. Mix ordinary single-select items, passage-based items, and multiple-select items that require exactly two answers. Separately practice the four written-response prompt categories with your own eligible project evidence. When reviewing mistakes, name the violated rule: list position, update order, missing precondition, unsupported causal claim, untested boundary, or mismatch among Create materials.
Give Algorithms and Programming the largest review block because its published multiple-choice range is 30–35%, while keeping all five Big Ideas active. The other ranges are Creative Development 10–13%, Data 17–22%, Computer Systems and Networks 11–15%, and Impact of Computing 21–26%. These ranges guide study time; they do not predict an exact form and they do not divide the Create score.
Use the supplied support correctly. The exam provides the AP CSP Exam Reference Sheet, and students use an approved Personalized Project Reference for the written responses. Those materials do not decide whether an abstraction manages complexity, whether a procedure is efficient, whether a test covers a boundary, or whether a computing-impact claim is supported. Practice making those links aloud and in writing.
AskSia is not affiliated with or endorsed by College Board®. AP is a registered trademark of College Board®. Exam facts and Big Idea percentages are based on official College Board information as of 2026-08-29. Every practice situation, value, program, trace, and explanation in this guide was independently written for instruction.
