1.3 Program Design and Development

TLDR

Program design and development is how you take a program from an idea to a working solution. You will investigate what users need, design the program and its interface, build and test it, and document your code along the way. AP Computer Science Principles wants you to know two main approaches: iterative development (refine through repeated cycles) and incremental development (build and verify one piece at a time).

more resources to help you study

practice multiple choiceFRQ practice & scoringcheatsheetsscore calculator

Why This Matters for the AP Computer Science Principles Exam

This topic is part of Creative Development, which centers on how programs are planned, built, and improved. You will use these ideas directly when you build your program for the Create performance task, since you choose the topic and the development process you follow. On the multiple-choice section, you can expect questions that ask you to identify development phases, tell iterative from incremental development apart, recognize why documentation matters, and explain when and how to acknowledge code from other sources. Being able to explain how a program or code segment functions also connects to questions that test how well you understand what a chunk of code does.

Key Takeaways

• A development process can be ordered and intentional, or exploratory where you experiment as you go.
• Common phases are investigating and reflecting, designing, prototyping, and testing.
• Iterative development means refining and revising based on feedback, testing, or reflection, which can send you back to earlier phases.
• Incremental development means breaking the problem into smaller pieces and confirming each piece works before adding it to the whole.
• Investigation (surveys, user testing, interviews, direct observations) helps you define requirements and a program specification.
• Document your code as you go, and always acknowledge any code segments written by someone else.

Types of Development Processes

There are many ways to create a program, and AP Computer Science Principles does not require you to follow one specific method.

Some development processes are ordered and intentional. They follow a planned path where each step is deliberate. Other processes are exploratory in nature, meaning the programmer experiments as they go. This can happen when a program does not have specific guidelines or when developers are working under time constraints.

Whatever the approach, most development processes move through the same set of common phases:

• investigating and reflecting
• designing
• prototyping
• testing

The two specific types of development you need to know are iterative and incremental.

Iterative and Incremental Development Processes

When you think of "iteration," think of repetition.

In an iterative development process, you refine and revise your program based on feedback, testing, or reflection. This can require revisiting earlier phases. You might build a working prototype, test it, learn something, and then loop back to redesign part of it.

In an incremental development process, you break the program into smaller pieces and make sure each piece works before adding it to the whole.

Programs can be developed using either approach, or any combination of the two. For example, you might take one code segment of a larger program and revise it until it is complete, then move on to the next part. Revising that one segment to completion is an iterative move, while building the program piece by piece is an incremental one.

Phases of Program Development

A lot of work goes into a program before anyone opens a code editor. The beginning steps for most development processes are the planning phases.

Investigating and Reflecting

This is the planning stage where you make the program's goal as clear as possible. You establish your purpose and the problem you are trying to solve, then figure out what the program needs to do and what it needs in order to function correctly.

Investigation helps you understand the program's constraints as well as the concerns and interests of the people who will use it. Some ways to investigate include:

• collecting data through surveys
• user testing
• interviews
• direct observations

In an iterative process, this stage also includes reflecting on how the project could improve or why something is not working. With every repetition, the questions you investigate and reflect on become more specific.

Designing

The design phase outlines how to accomplish a given program specification. In other words, once you know what the program must do, this phase plans how to make it happen.

The design phase may include:

• brainstorming
• planning and storyboarding
• organizing the program into modules and functional components
• creating diagrams that represent the layouts of the user interface
• developing a testing strategy for the program (see 1.4 Identifying and Correcting Errors)

Program Requirements and Specifications

Through investigation, you discover your program's requirements. Program requirements describe how a program functions and may include a description of the user interactions the program must provide. They answer questions like: What should a user be able to do? What does a user need to provide for the program to work?

A program's specification defines those requirements. Once the specification is written, you can start prototyping, building, and testing your program against it.

A user interface is part of this design thinking too. A well-designed user interface makes it easy for the user to understand what data the program needs as input. Planning how your program should behave for different inputs can also help you catch logic errors early.

Program Documentation

Program documentation is a written description of the function of a code segment, event, procedure, or program and how it was developed. Think of it as notes and summaries for your code.

Documentation matters for several reasons:

• Programs are complex, and it can be hard to understand one just by reading the code. Documentation explains how the parts work.
• Documentation supports collaboration. Someone other than the original programmer may need to work with the code later.
• Documentation helps in developing and maintaining correct programs whether you work alone or in a group.

You should document your program throughout its development, not just at the end.

Comments

One of the most common forms of program documentation is comments. Comments are documentation written directly into the program to be read by people, and they do not affect how the program runs.

Comments are usually marked by a symbol that tells the computer to ignore that text when running the program. For example, in many languages a line starting with # is treated as a comment:

</>Code
# This loop counts from 1 to 10

Most languages you use in this course support comments, but not all programming environments do. When comments are not supported, you will need other methods of documentation.

Acknowledging Code From Other Sources

As you go further in computer science, you will run into situations where you want to use code that someone else helped create. Maybe a friend helped on a project, maybe it came from a group, or maybe you found a code segment that does exactly what you need.

It is important to acknowledge any code segments that were developed collaboratively or by another source. You can put this acknowledgement in your program documentation, and it should include the origin or the original author's name.

A simple checklist:

• Check whether you are allowed to use the code for your assignment.
• Make sure you have permission to use it, since code is often licensed with specific usage rules.
• Acknowledge the source in your documentation, naming where the code came from and who wrote it.

How to Use This on the AP Computer Science Principles Exam

MCQ

• Match a scenario to the correct development phase (investigating and reflecting, designing, prototyping, or testing).
• Tell iterative from incremental development apart. Iterative is about refining and revisiting; incremental is about building and verifying one piece at a time.
• Recognize investigation methods (surveys, user testing, interviews, direct observations) and how they help define requirements.
• Identify why documentation and comments are useful, and remember comments do not change how a program runs.

Create Performance Task

• You choose your own topic, so also choose a development process that fits it. You can use iterative cycles, incremental building, or both.
• Document your code as you build it so your written responses about the program are accurate.
• If you use any code you did not write yourself, acknowledge the source and the original author in your documentation.

Common Trap

• Do not assume comments affect program output. They are for people to read and are ignored when the program runs.
• Do not treat "iterative" and "incremental" as the same word. They can overlap, but they describe different things.

Common Misconceptions

• "There is one official AP development process." There is not. A development process can be ordered and intentional or exploratory, and AP Computer Science Principles does not require a single method for the Create performance task.
• "Iterative and incremental mean the same thing." Iterative is about refining through repeated cycles and revisiting earlier phases. Incremental is about breaking the problem into pieces and confirming each one works before adding it.
• "Comments make a program run differently." Comments are documentation for people and do not affect how a program runs.
• "Documentation only happens at the end." You should document throughout development, not just after the program is finished.
• "Investigation is just guessing what users want." Investigation uses real methods like surveys, user testing, interviews, and direct observations to define requirements.
• "Using someone else's code is fine as long as it works." You need to acknowledge code from other sources in your documentation, including where it came from and who wrote it.

Related AP Computer Science Principles Guides

• 1.4 Identifying and Correcting Errors
• 1.1 Collaboration
• 1.2 Program Function and Purpose
• Big Idea 1 Overview: Creative Development