Skip to main content

AP Computer Science Principles Unit 1 Review: Creative Development

  • 10–13% of AP multiple choice
  • 4 topics
  • AP exam review verified for 2027

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

Fiveable's AP Computer Science Principles Unit 1 review covers 5 topics, with guided practice questions for the unit.

start with 1.1start unit practiceReview with a tutorReal people, 24/7, from UPchieve. Free for eligible students.

AP Computer Science Principles unit 1 topics

1.1

Collaboration

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.

open guide
1.2

Program Function and Purpose

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.

open guide
1.3

Program Design and Development

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.

open guide
1.4

Identifying and Correcting Errors

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.

open guide

Practice AP Computer Science Principles unit 1 questions

Try AP-style questions on unit 1, then use the review notes below for anything you miss.

AP Computer Science Principles unit 1 practice MCQs

open all practice
MCQ

AP-style practice question

Question

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?

Maintaining a constant temperature setting throughout the entire day and night.

Increasing the cooling intensity immediately whenever the outdoor heat peaks.

Disabling the cooling system entirely whenever the user is away from the home.

Pre-cooling the home during low-rate hours to minimize usage during peak times.

MCQ

AP-style practice question

Question

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?

It reduces the model's complexity by simplifying car behavior, but the simulation still crashes because abstraction cannot eliminate memory constraints imposed by hardware limitations.

It reduces the model's complexity by filtering out irrelevant details, but increases runtime performance instead of addressing the memory overflow that caused the crash.

It reduces the model's complexity by replacing detailed physics calculations with simplified movement logic, but requires additional memory to store the abstraction layer itself.

It reduces the model's complexity by filtering out irrelevant details, ensuring the simulation runs within the hardware's memory limits.

AP Computer Science Principles unit 1 FRQs

open all FRQs
FRQ

Test and explain a greeting-program prototype

Early-unit written response practice: three short tasks using a supplied example program. This adapts tracing, testing, and data reasoning from the written-response task family. It does not assess the full Create/PPR requirements for lists, iteration, or student-developed procedures. No personal project, code file, or video is required.

A school club wants a sign-in kiosk to display a greeting containing the visitor’s entered name. The following program is its prototype. INPUT reads the entered text, ← assigns a value to a named variable, + joins text, and DISPLAY shows text on the screen. The visitor enters Maya.

</>TEXT
name ← INPUT()  
message ← "Hello, " + name  
DISPLAY(message)  
A.

Describe the sequence of actions the program performs and identify its displayed output for the supplied input.

B.

Propose a different name as test input and state the exact expected output. Explain how this test checks the kiosk’s stated design requirement.

C.

Suppose the first line is changed to name ← "Maya" so that it no longer reads input. Explain one limitation this change would create for visitors other than Maya and why the original input variable avoids that limitation.

AP Computer Science Principles unit 1 practice test

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.

Take the unit 1 practice test

Unit 1 review notes

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.

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 ModelHow It WorksKey Benefit
Pair programmingTwo programmers at one workstation, one writes and one reviewsReal-time error catching and knowledge sharing
Online tools (e.g., shared docs, version control)Asynchronous sharing and feedback on code or documentsSupports distributed teams and tracks changes over time
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.

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?

ConceptDefinitionExample
PurposeWhy the program was createdA navigation app exists to help users find routes
FunctionWhat the program does during executionThe app takes a destination input and outputs turn-by-turn directions
InputData sent to the programUser types a destination address
OutputData sent from the program to a deviceMap display and audio directions
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.

Can you explain the difference between iterative and incremental development? Can you name three investigation methods used to gather program requirements?

Development TypeCore IdeaWhen You Revisit Earlier Work
IterativeRefine through repeated cycles based on feedback or testingYes, revisiting earlier phases is expected and built into the process
IncrementalBuild and verify one piece at a time before adding to the wholeOnly if a piece fails; focus is on completing verified chunks
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.

Can you identify which error type matches a given scenario? Can you explain why testing with boundary inputs is important for finding errors?

Error TypeWhen It OccursExample
Logic errorDuring or after execution; code runs but gives wrong outputA loop runs one too many times, producing an off-by-one result
Syntax errorBefore execution; language rules violatedMissing closing parenthesis in a function call
Run-time errorDuring executionDividing by zero when user input is 0
Overflow errorDuring executionAdding 1 to the maximum integer value a variable can store

Key terms

TermDefinition
Iterative Development ProcessA 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 programmingA 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 InputsData sent to a program for processing. Inputs can be tactile, audio, visual, or text, and can come from users or other programs.
Code SegmentA collection of program statements that is part of a larger program, used to perform a specific task or operation.
Program DocumentationWritten descriptions of what code segments, events, procedures, or programs do and how they were developed, used to help others understand and maintain the code.
CommentsText 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 RequirementsA description of how a program must function, including required user interactions, gathered through surveys, interviews, user testing, and direct observation.
logic errorA mistake in an algorithm or program that causes it to behave incorrectly or unexpectedly, even though the code may run without crashing.
syntax errorA mistake in a program where the rules of the programming language are not followed, usually preventing the program from running.
run-time errorA mistake in a program that occurs during execution. Each programming language defines its own run-time errors.
Hand TracingManually stepping through code line by line and tracking variable values at each step to find where behavior diverges from what was intended.
DebuggingThe 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 DesignThe 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 TaskThe AP CSP exam component where students design and implement a program, document their development process, and explain their program's purpose, function, and testing.

How to review unit 1

Topics students miss most

Miss rates come from Fiveable multiple-choice practice.

1.1
25%4,291 tries

Mistakes to avoid in Creative Development

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.

Creative Development on the AP exam

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.

Study unit 1 other ways

Unit 1 printables

Print the unit cheatsheets ($3) for Unit 1. Yours to keep, no subscription needed.

get printables

Frequently Asked Questions

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.

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.

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.

Ready to review Unit 1?Start with the notes, check the topic cards, and use the practice or resource links when they are available for this course.