Review AP CSP Unit 1 to understand how computing innovations are built through collaboration, intentional design, and iterative development. This unit covers everything from pair programming and user feedback to identifying logic, syntax, run-time, and overflow errors.
Use the topic guides, practice questions, and FRQ practice available here to work through all four topics before your exam.
Creative Development is about the process behind building computing innovations, not just the end product. The College Board wants you to understand that good programs come from working with others, gathering user feedback, designing deliberately, and testing carefully.
Unit 1 covers four topics: how collaboration improves computing innovations (1.1), what programs do and how inputs and outputs work (1.2), how programs are designed and documented through iterative and incremental processes (1.3), and how to find and fix logic, syntax, run-time, and overflow errors (1.4).
Diverse teams catch bias, incorporate more perspectives, and produce innovations that work for a wider range of users. Pair programming and online collaboration tools like shared documents and version control support this process.
The four common development phases are investigating, designing, prototyping, and testing. Iterative development means revisiting earlier phases based on feedback. Documentation through comments and written descriptions helps others understand and maintain code.
Unit 1 frames the entire course by showing that programs are the result of deliberate human choices: who collaborates, what users need, how the design evolves, and how errors get caught. These ideas connect directly to the Create Performance Task, where you must document your own development process and explain your program's purpose, function, and testing.
Explains how diverse teams and user consultation improve computing innovations. Covers pair programming, online collaboration tools, and the four interpersonal skills: communication, consensus building, conflict resolution, and negotiation.
Covers the difference between a program's purpose and its function, how inputs and outputs work, and how event-driven programming triggers code through events like key presses and mouse clicks rather than sequential flow.
Covers the four development phases (investigating, designing, prototyping, testing), the difference between iterative and incremental development, how to gather program requirements, and how to write documentation and comments.
Covers the four error types (logic, syntax, run-time, overflow) and the five debugging strategies: test cases, hand tracing, visualizations, debuggers, and adding extra output statements. Includes how to design boundary test inputs.
AP Computer Science Principles Big Idea 1 review: collaboration, program design, and error types across Topics 1.1-1.4, worth 10-13% of the exam, with practice links.
This snapshot uses Fiveable practice activity to show where students tend to miss questions and which review moves are worth prioritizing first.
Across 16k multiple-choice practice attempts for this unit.
Practice activity included in this snapshot.
Across 26 scored free-response attempts for this unit.
Review Program Design and Development with attention to how the concept appears in AP-style source and evidence questions.
Review Program Function and Purpose with attention to how the concept appears in AP-style source and evidence questions.
Review Collaboration with attention to how the concept appears in AP-style source and evidence questions.
Computing innovations improve when teams include people with different backgrounds and skills. Collaboration reduces bias because diverse perspectives surface assumptions that a homogeneous team might miss. Consulting and communicating with actual users is a required part of the development process, not optional.
Can you explain two specific ways that including diverse perspectives improves a computing innovation? Can you name the four interpersonal skills the AP exam expects you to know?
| Collaboration Model | How It Works | Key Benefit |
|---|---|---|
| Pair programming | Two programmers at one workstation, one writes and one reviews | Real-time error catching and knowledge sharing |
| Online tools (e.g., shared docs, version control) | Asynchronous sharing and feedback on code or documents | Supports distributed teams and tracks changes over time |
Every program exists to solve a problem or support creative expression. Knowing the purpose helps developers build the right thing. Function describes what the program does during execution, including how it responds to inputs and produces outputs. Event-driven programs do not run top to bottom; they wait for defined events to trigger specific code.
Can you distinguish between a program's purpose and its function? Can you give an example of an event and explain how it triggers program behavior?
| Concept | Definition | Example |
|---|---|---|
| Purpose | Why the program was created | A navigation app exists to help users find routes |
| Function | What the program does during execution | The app takes a destination input and outputs turn-by-turn directions |
| Input | Data sent to the program | User types a destination address |
| Output | Data sent from the program to a device | Map display and audio directions |
Programs are developed through phases: investigating and reflecting, designing, prototyping, and testing. Iterative development means you cycle back through earlier phases when testing reveals problems. Incremental development means you build and verify one piece at a time before adding it to the whole. Documentation through comments and written descriptions is required throughout, not just at the end. Any code from another source must be acknowledged in documentation.
Can you explain the difference between iterative and incremental development? Can you name three investigation methods used to gather program requirements?
| Development Type | Core Idea | When You Revisit Earlier Work |
|---|---|---|
| Iterative | Refine through repeated cycles based on feedback or testing | Yes, revisiting earlier phases is expected and built into the process |
| Incremental | Build and verify one piece at a time before adding to the whole | Only if a piece fails; focus is on completing verified chunks |
There are four error types you must know for the AP exam. Logic errors cause incorrect behavior even when the code runs. Syntax errors break the rules of the programming language and usually prevent the program from running at all. Run-time errors occur during execution. Overflow errors happen when a number exceeds the defined range a computer can handle. Finding errors requires deliberate testing with defined inputs, including values at or just beyond the extremes of expected input.
Can you identify which error type matches a given scenario? Can you explain why testing with boundary inputs is important for finding errors?
| Error Type | When It Occurs | Example |
|---|---|---|
| Logic error | During or after execution; code runs but gives wrong output | A loop runs one too many times, producing an off-by-one result |
| Syntax error | Before execution; language rules violated | Missing closing parenthesis in a function call |
| Run-time error | During execution | Dividing by zero when user input is 0 |
| Overflow error | During execution | Adding 1 to the maximum integer value a variable can store |
Try AP-style multiple-choice questions and written prompts after you review the notes.
A timed, AP-style test built only from unit 1 questions — multiple choice plus free response, scored with AI feedback. Use the standard format or build your own.
| Term | Definition |
|---|---|
| Iterative Development Process | A development approach where the program is refined through repeated cycles of investigating, designing, prototyping, and testing, with earlier phases revisited based on feedback or test results. |
| pair programming | A collaboration model where two programmers work together at one workstation: one writes code while the other reviews in real time, improving quality and shared understanding. |
| Program Inputs | Data sent to a program for processing. Inputs can be tactile, audio, visual, or text, and can come from users or other programs. |
| Code Segment | A collection of program statements that is part of a larger program, used to perform a specific task or operation. |
| Program Documentation | Written descriptions of what code segments, events, procedures, or programs do and how they were developed, used to help others understand and maintain the code. |
| Comments | Text written into source code to explain it to human readers. Comments do not affect how the program runs and are a required form of documentation. |
| Program Requirements | A description of how a program must function, including required user interactions, gathered through surveys, interviews, user testing, and direct observation. |
| logic error | A mistake in an algorithm or program that causes it to behave incorrectly or unexpectedly, even though the code may run without crashing. |
| syntax error | A mistake in a program where the rules of the programming language are not followed, usually preventing the program from running. |
| run-time error | A mistake in a program that occurs during execution. Each programming language defines its own run-time errors. |
| Hand Tracing | Manually stepping through code line by line and tracking variable values at each step to find where behavior diverges from what was intended. |
| Debugging | The process of finding and fixing errors in a program using strategies such as test cases, hand tracing, visualizations, debuggers, and extra output statements. |
| User Interface Design | The process of planning how users will interact with a program, including layouts and input methods, as part of the design phase of development. |
| Create Performance Task | The AP CSP exam component where students design and implement a program, document their development process, and explain their program's purpose, function, and testing. |
A logic error produces wrong output but the program still runs. A run-time error crashes or halts the program during execution. Students often label any error that appears while running as a run-time error, but if the program finishes and just gives the wrong answer, that is a logic error.
Iterative development means cycling back through phases based on feedback. Incremental development means building and verifying one piece at a time. A program can use both, but they describe different aspects of the process and the AP exam tests them separately.
Purpose is why the program was created (the problem it solves or the creative goal). Function is what the program actually does during execution. Exam questions often ask you to describe one specifically, so using the wrong term costs points.
Testing only typical inputs misses errors that appear at the edges. The AP exam expects you to know that defined test inputs should include values at or just beyond the minimum and maximum of expected input data.
Any code segment written by someone else and used in your program must be acknowledged in documentation with the origin or original author's name. Leaving this out is both an academic integrity issue and a testable AP concept.
Multiple-choice questions frequently present a short code segment or scenario and ask you to identify whether the error is a logic, syntax, run-time, or overflow error. Practice reading code carefully: if it runs but gives wrong output, think logic error; if it violates language rules, think syntax error; if it crashes during execution, think run-time error.
Questions may describe a development scenario and ask you to identify which phase is occurring, whether the process is iterative or incremental, or why a developer would return to an earlier phase. Be ready to connect investigation methods (surveys, interviews, user testing, direct observation) to the goal of gathering program requirements.
The Create Performance Task directly assesses Unit 1 skills. You must describe your program's purpose and function, explain how you used an iterative development process, document your code with comments, and acknowledge any code from other sources. The written responses on the task use the same vocabulary tested in Unit 1 multiple-choice questions.
Explain how diverse perspectives reduce bias in computing innovations. Name the four interpersonal skills and describe how pair programming and online tools support collaboration.
Distinguish between why a program was created (purpose) and what it does during execution (function). Give examples of physical, nonphysical software, and nonphysical concept innovations.
Identify input types (tactile, audio, visual, text) and output types. Explain how event-driven programming differs from sequential flow and give examples of events that trigger program behavior.
Name the four development phases and explain the difference between iterative and incremental development. Describe at least three investigation methods used to gather program requirements.
Explain what program documentation includes, how comments work, and why code from other sources must be acknowledged with the origin or original author's name in documentation.
Identify and distinguish logic, syntax, run-time, and overflow errors. Match each error type to a scenario and explain when each occurs.
Describe all five error-finding strategies: test cases, hand tracing, visualizations, debuggers, and extra output statements. Explain why boundary inputs (at or just beyond extremes) are important for testing.
Read the Topic 1.1 guide on Fiveable. Focus on why diverse perspectives reduce bias, the definition of a computing innovation, and the four interpersonal skills. Practice explaining the difference between pair programming and using online collaboration tools.
Read the Topic 1.2 guide. Write out the distinction between purpose and function in your own words. Then trace through a simple event-driven scenario: identify the event, the input, and the resulting output.
Read the Topic 1.3 guide. Draw a diagram of the four development phases and annotate where iterative feedback loops occur. Practice writing a short comment for a code segment and a one-sentence attribution for borrowed code.
Read the Topic 1.4 guide. Use the comparison table to drill all four error types until you can match each to a scenario. Practice hand tracing a short algorithm and identify where a logic error would appear.
Use the Big Idea 1 overview guide to review all four topics together. Work through the available practice questions and FRQ practice to apply concepts in exam-style contexts. Use the AP score calculator to estimate where you stand.
Open the individual guides for Unit 1 when you want a closer review of one topic.
Use AP-style practice after you review the notes so you can check what you understand.
Practice free-response reasoning and compare your answer with scoring guidance.
Watch past review streams filtered to Unit 1 when you want a video walkthrough.
Open the Fiveable one-page unit review, then explore visual cheatsheets for a quick refresher.
Estimate your broader AP score goal after you review the course and exam format.
Print the unit cheatsheets ($3) or unit exams ($5) for Unit 1. Yours to keep, no subscription needed.
get printablesAP CSP Unit 1: Creative Development covers 4 topics: **1.1 Collaboration**, **1.2 Program Function and Purpose**, **1.3 Program Design and Development**, and **1.4 Identifying and Correcting Errors**. Together they build the foundation for how programs are designed, built, and debugged through an iterative, user-centered process. See the full topic breakdown at AP CSP Unit 1.
The AP CSP Unit 1 progress check in AP Classroom includes both MCQ and FRQ parts drawn from all 4 unit topics: Collaboration, Program Function and Purpose, Program Design and Development, and Identifying and Correcting Errors. MCQ questions test conceptual understanding, while the FRQ section asks you to apply design and debugging thinking to short scenarios. For matched practice questions that mirror the progress check format, visit AP CSP Unit 1.
AP CSP Unit 1 FRQs most often draw from Program Design and Development (1.3) and Identifying and Correcting Errors (1.4), asking you to trace through a design process, explain a program's purpose, or identify and fix a specific bug. Practice by writing out step-by-step explanations for short code or design scenarios, then checking whether your answer addresses the prompt's exact ask. You can find FRQ-style practice at AP CSP Unit 1.
The best place to find AP CSP Unit 1 practice questions, including multiple-choice and practice test sets, is AP CSP Unit 1. That page organizes MCQ and FRQ practice by topic, covering Collaboration, Program Function and Purpose, Program Design and Development, and Identifying and Correcting Errors, so you can target exactly what you need.
Start AP CSP Unit 1 by understanding the iterative design cycle: how collaboration (1.1) shapes a program's purpose (1.2), how that purpose drives design decisions (1.3), and how testing reveals errors to fix (1.4). Study each topic in that order since they build on each other. For 1.4, practice tracing code line by line to spot logic, syntax, and runtime errors. Then test yourself with MCQ questions to check your understanding before moving on. Find topic guides and practice sets at AP CSP Unit 1.