---
title: "AP CSP Unit 1 Review: Creative Development | Fiveable"
description: "AP Computer Science Principles Unit 1 covers Collaboration and Program Function and Purpose. Study guides, practice questions, and key terms for every topic."
canonical: "https://fiveable.me/ap-comp-sci-p/unit-1"
type: "unit"
subject: "AP Computer Science Principles"
unit: "Unit 1 – Creative Development"
---

# AP CSP Unit 1 Review: Creative Development | Fiveable

## Overview

Unit 1 establishes the foundation for how programs are created. You will learn why collaboration and diverse perspectives improve computing innovations, how to describe program function and purpose using inputs and outputs, how iterative and incremental development processes work, and how to identify and correct the four main error types.

## AP CED Alignment

This unit hub is organized around AP Course and Exam Description topics, skills, and exam task types when they are available in the source data.
- Topic 1.1: Collaboration
- Topic 1.2: Program Function and Purpose
- Topic 1.3: Program Design and Development
- Topic 1.4: Identifying and Correcting Errors
- guide: Big Idea 1 Overview: Creative Development
- Practice 1: Computational Solution Design
- Practice 3: Abstraction in Program Development
- Written Response 2

## Topics

- [Topic 1.1: Collaboration](/ap-comp-sci-p/unit-1/collaboration/study-guide/3a4PT1Lq1XBH8u3Nnb7V): 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.
- [Topic 1.2: Program Function and Purpose](/ap-comp-sci-p/unit-1/program-function-purpose/study-guide/8hL8KatG4rAWTwZSglGB): 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.
- [Topic 1.3: Program Design and Development](/ap-comp-sci-p/unit-1/program-design-development/study-guide/SsouN8LrhRWiQ5hevIV6): 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.
- [Topic 1.4: Identifying and Correcting Errors](/ap-comp-sci-p/unit-1/identifying-correcting-errors/study-guide/pz4hGcBBElziI3R8cfnQ): 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.
- [guide: Big Idea 1 Overview: Creative Development](/ap-comp-sci-p/unit-1/review/study-guide/x5UA88sFgn3CtCwjzDaq): 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.

## Hardest Topics And Analytics

Snapshot: practice snapshot
This snapshot uses Fiveable practice activity to show where students tend to miss questions and which review moves are worth prioritizing first.
- **70% average MCQ accuracy** (Across 16k multiple-choice practice attempts for this unit.)
- **16k MCQ attempts** (Practice activity included in this snapshot.)
- **83% average FRQ score** (Across 26 scored free-response attempts for this unit.)
- **Topic 1.3: Program Design and Development**: 33% MCQ miss rate across 3893 attempts. Review Program Design and Development with attention to how the concept appears in AP-style source and evidence questions.
- **Topic 1.2: Program Function and Purpose**: 28% MCQ miss rate across 4366 attempts. Review Program Function and Purpose with attention to how the concept appears in AP-style source and evidence questions.
- **Topic 1.1: Collaboration**: 25% MCQ miss rate across 4291 attempts. Review Collaboration with attention to how the concept appears in AP-style source and evidence questions.

## Review Notes

### Topic 1.1: Collaboration

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.

- **Computing innovation**: Any innovation with a program as an integral part of its function. Can be physical (self-driving car), nonphysical software (photo editing app), or a nonphysical concept (e-commerce).
- **Pair programming**: A collaboration model where one programmer writes code while the other reviews in real time, improving quality and shared understanding.
- **Online collaboration tools**: Shared documents, version control systems, and collaborative IDEs allow programmers to share code, give feedback, and work asynchronously.
- **Interpersonal skills**: Effective teams practice communication, consensus building, conflict resolution, and negotiation to keep development on track.
- **User consultation**: Gathering information from potential users helps developers understand diverse needs and build programs that reflect those perspectives.

**Checkpoint:** 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

### Topic 1.2: Program Function and Purpose

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.

- **Program purpose**: Why a computing innovation was created: to solve a problem or pursue creative expression.
- **Program function**: What a program does during execution, often described by how a user interacts with it.
- **Code segment**: A collection of program statements that is part of a larger program.
- **Program inputs**: Data sent to a program for processing. Can be tactile, audio, visual, or text, and can come from users or other programs.
- **Event-driven programming**: A model where program statements execute when triggered by events such as key presses, mouse clicks, or program start, rather than through sequential flow.

**Checkpoint:** 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

### Topic 1.3: Program Design and Development

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.

- **Iterative development**: A process that requires refinement and revision based on feedback, testing, or reflection, which may mean revisiting earlier phases.
- **Incremental development**: Breaking a program into smaller pieces and verifying each piece works before combining it with the rest.
- **Program requirements**: A description of how a program must function, including required user interactions. Gathered through surveys, interviews, user testing, and direct observation.
- **Program documentation**: Written descriptions of what code segments, events, procedures, or programs do and how they were developed.
- **Comments**: Text written into source code to explain it to human readers. Comments do not affect how the program runs.

**Checkpoint:** 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

### Topic 1.4: Identifying and Correcting Errors

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.

- **Logic error**: A mistake in the algorithm that causes incorrect or unexpected behavior. The code may run without crashing but produces wrong results.
- **Syntax error**: A violation of the programming language's rules. Usually caught before the program runs.
- **Run-time error**: An error that occurs while the program is executing. Each programming language defines its own run-time errors.
- **Overflow error**: Occurs when a computer tries to handle a number outside the defined range of values it can store.
- **Hand tracing**: Manually stepping through code line by line, tracking variable values at each step, to find where behavior diverges from expectations.

**Checkpoint:** 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

## Study Guides

- [1.1 Collaboration](/ap-comp-sci-p/unit-1/collaboration/study-guide/3a4PT1Lq1XBH8u3Nnb7V)
- [1.2 Program Function and Purpose](/ap-comp-sci-p/unit-1/program-function-purpose/study-guide/8hL8KatG4rAWTwZSglGB)
- [1.3 Program Design and Development](/ap-comp-sci-p/unit-1/program-design-development/study-guide/SsouN8LrhRWiQ5hevIV6)
- [1.4 Identifying and Correcting Errors](/ap-comp-sci-p/unit-1/identifying-correcting-errors/study-guide/pz4hGcBBElziI3R8cfnQ)
- [Big Idea 1 Overview: Creative Development](/ap-comp-sci-p/unit-1/review/study-guide/x5UA88sFgn3CtCwjzDaq)

## Practice Preview

### Multiple-choice practice

- **AP-style practice question**: Practice 1: Computational Solution Design | A smart thermostat is designed to reduce electricity costs for homeowners. The utility company charges higher rates during peak afternoon hours and lower rates at night. Which program behavior best achieves the purpose of cost reduction?
- **AP-style practice question**: Practice 3: Abstraction in Program Development | A traffic simulation program crashes because it attempts to track the tire friction of every car, exceeding the computer's memory. The developer modifies the program to treat cars as simple points moving at constant speeds. How does this change correct the error using abstraction?
- **AP-style practice question**: Practice 3: Abstraction in Program Development | A student writes a complex algorithm to find the shortest path in a grid, but it contains a logic error that causes infinite loops. The student replaces the custom code with a call to a standard pathfinding library. How does this modification correct the error and manage complexity?
- **AP-style practice question**: Practice 3: Abstraction in Program Development | A program tracks the prices of five items using variables `item1` through `item5`. A logic error occurs because the code to calculate the total fails to include `item5`. The developer changes the code to use a list `items` and a loop. Which explanation best describes how this abstraction manages complexity?
- **AP-style practice question**: Practice 3: Abstraction in Program Development | A procedure `drawSquare()` is designed to draw a square of size 50, but it fails to work for other sizes needed in the program. The developer updates the procedure to `drawSquare(sideLength)`. How does this change correct the error and manage complexity?
- **AP-style practice question**: Practice 3: Abstraction in Program Development | A program calculates the area of three different circles using the formula `3.14 * r * r` copied three times. A typo in the third copy causes a logic error. The developer replaces the repeated code with a single procedure `calculateArea(r)`. Which statement best explains how this correction manages complexity?

### FRQ practice

- **Boolean expressions, procedures, and list modifications**: Written Response 2 | Boolean expressions, procedures, and list modifications

## Key Terms

- **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.

## Common Mistakes

- **Confusing logic errors with run-time errors**: 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.
- **Treating iterative and incremental development as the same thing**: 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.
- **Describing program purpose and function as interchangeable**: 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.
- **Skipping boundary inputs when designing test cases**: 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.
- **Omitting attribution for borrowed code in documentation**: 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.

## Exam Connections

- **Identifying error types from code or scenario descriptions**: 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.
- **Explaining development process decisions**: 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.
- **Create Performance Task connections**: 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.

## Final Review Checklist

- **Unit 1 review checklist: Collaboration**: Explain how diverse perspectives reduce bias in computing innovations. Name the four interpersonal skills and describe how pair programming and online tools support collaboration.
- **Unit 1 review checklist: Program purpose vs. function**: 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.
- **Unit 1 review checklist: Inputs, outputs, and events**: 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.
- **Unit 1 review checklist: Development process**: 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.
- **Unit 1 review checklist: Documentation and attribution**: 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.
- **Unit 1 review checklist: Error types**: Identify and distinguish logic, syntax, run-time, and overflow errors. Match each error type to a scenario and explain when each occurs.
- **Unit 1 review checklist: Debugging strategies**: 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.

## Study Plan

- **Step 1: Collaboration (Topic 1.1)**: 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.
- **Step 2: Program function, purpose, inputs, and outputs (Topic 1.2)**: 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.
- **Step 3: Design, development, and documentation (Topic 1.3)**: 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.
- **Step 4: Error types and debugging (Topic 1.4)**: 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.
- **Step 5: Full unit review and practice**: 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.

## More Ways To Review

- [Topic study guides](/ap-comp-sci-p/unit-1#topics)
- [FRQ practice](/ap-comp-sci-p/frq-practice)
- [Cram archive videos](/cram-archives?subject=ap-computer-science-principles&unit=unit-1)
- [Cheatsheets](/ap-comp-sci-p/cheatsheets/unit-1)
- [Key terms](/ap-comp-sci-p/key-terms)

## FAQs

### What topics are covered in AP CSP Unit 1?

AP 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](/ap-comp-sci-p/unit-1).

### What's on the AP CSP Unit 1 progress check (MCQ and FRQ)?

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-comp-sci-p/unit-1).

### How do I practice AP CSP Unit 1 FRQs?

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](/ap-comp-sci-p/unit-1).

### Where can I find AP CSP Unit 1 practice questions?

The best place to find AP CSP Unit 1 practice questions, including multiple-choice and practice test sets, is [AP CSP Unit 1](/ap-comp-sci-p/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.

### How should I study AP CSP Unit 1?

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](/ap-comp-sci-p/unit-1).

## Structured Data

```json
{"@context":"https://schema.org","@type":"FAQPage","inLanguage":"en","mainEntity":[{"@type":"Question","@id":"https://fiveable.me/ap-comp-sci-p/unit-1#what-topics-are-covered-in-ap-csp-unit-1","name":"What topics are covered in AP CSP Unit 1?","acceptedAnswer":{"@type":"Answer","text":"AP 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 <a href=\"/ap-comp-sci-p/unit-1\">AP CSP Unit 1</a>."}},{"@type":"Question","@id":"https://fiveable.me/ap-comp-sci-p/unit-1#whats-on-the-ap-csp-unit-1-progress-check-mcq-and-frq","name":"What's on the AP CSP Unit 1 progress check (MCQ and FRQ)?","acceptedAnswer":{"@type":"Answer","text":"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 <a href=\"/ap-comp-sci-p/unit-1\">AP CSP Unit 1</a>."}},{"@type":"Question","@id":"https://fiveable.me/ap-comp-sci-p/unit-1#how-do-i-practice-ap-csp-unit-1-frqs","name":"How do I practice AP CSP Unit 1 FRQs?","acceptedAnswer":{"@type":"Answer","text":"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 <a href=\"/ap-comp-sci-p/unit-1\">AP CSP Unit 1</a>."}},{"@type":"Question","@id":"https://fiveable.me/ap-comp-sci-p/unit-1#where-can-i-find-ap-csp-unit-1-practice-questions","name":"Where can I find AP CSP Unit 1 practice questions?","acceptedAnswer":{"@type":"Answer","text":"The best place to find AP CSP Unit 1 practice questions, including multiple-choice and practice test sets, is <a href=\"/ap-comp-sci-p/unit-1\">AP CSP Unit 1</a>. 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."}},{"@type":"Question","@id":"https://fiveable.me/ap-comp-sci-p/unit-1#how-should-i-study-ap-csp-unit-1","name":"How should I study AP CSP Unit 1?","acceptedAnswer":{"@type":"Answer","text":"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 <a href=\"/ap-comp-sci-p/unit-1\">AP CSP Unit 1</a>."}}]}
```