Dove's LibraryDove's Library

Big Idea 1: Creative Development

Introduction to Computing Innovations

Computing innovations are constantly evolving, driven by human creativity and the ever-present desire to improve technology. These innovations can originate from virtually anywhere, reflecting the diverse needs and challenges of society.
What Counts as a Computing Innovation:
A computing innovation is any innovation that includes a computer program as an integral part of how it works. Take the program away and the innovation stops working. Computing innovations come in three kinds:
  • Physical: A real object that runs on a program, like a self-driving car, a smartwatch, or a smart thermostat.
  • Nonphysical computing software: A program itself, like picture editing software, a video game, or a music streaming app.
  • Nonphysical computing concept: An idea or way of doing things that computing makes possible, like e-commerce (buying and selling online), online banking, or social networking.
Purpose of Computing Innovations: Every computing innovation has a purpose. It either solves a problem (a GPS app finds the fastest route around traffic) or lets people pursue an interest through creative expression (a digital drawing app or a music-making program). Understanding the purpose helps developers build a better innovation, because it tells them who the users are, which features matter most, and how to tell if the innovation is doing its job.
Examples of Computing Innovations:
  • Crime Prevention: Technologies such as data mapping, tracking systems, and biometric verification have revolutionized the way we address security and law enforcement.
  • Healthcare: Insurance companies utilize data analytics to assess providers and determine the most effective care strategies.
  • Engineering and Communications: Advances in computing have spurred innovation in these fields, enhancing capabilities and efficiency.
  • The Arts: New computing techniques have introduced revolutionary ways to blend various media types, transforming artistic expression.
Not all innovations catch on immediately.
Impact of Computing on Other Fields:
Computing technology not only enhances functionality but also aids in modeling real-world scenarios and predicting outcomes by analyzing different variables. This integration of computing has contributed to increased creativity across multiple domains, including medicine, engineering, communications, and the arts.
Hardware vs. Software
  • Hardware: Refers to the physical components of a computing device, such as circuits, chips, and keyboards.
    • CPUs, Hard drives, GPUs, Motherboards
  • Software: Comprises the instructions and programs that command the hardware to perform tasks.
    • Operating systems, Application software, Web browsers, Database systems
While both elements are crucial, the essence of most computing innovations lies in the software, driving functionality and user interaction.
Moore's Law and Its Impact:
Moore's Law observes that the number of transistors on a microchip doubles approximately every two years, while the cost of each transistor keeps falling. This principle has seen computers evolve from room-sized machines like the ENIAC (1945), which took up about 1,800 square feet and weighed about 30 tons, to devices that fit comfortably in one's pocket.

Understanding Collaboration

Collaboration is an essential skill in the computing world, facilitating the pooling of diverse perspectives, skills, and experiences to enhance the development and execution of computing innovations. It helps in overcoming personal biases by integrating varied viewpoints, which is crucial for creating universally effective and inclusive technologies.
Scenario Demonstrating the Value of Collaboration:
Consider a health technology company developing an app to monitor heart health. If the development team consists only of software engineers without input from cardiologists, the app might not effectively address all medical needs or user concerns. By collaborating with medical professionals, the engineers gain insights into specific health requirements and user interfaces that are more appropriate for patients and doctors, making the app more effective and user-friendly.
Avoiding Bias: Everyone has blind spots that come from their own experiences. A team where everyone has the same background may not notice that their product works poorly for people unlike them. For example, a voice assistant tested only by people with one accent may misunderstand users with other accents. Collaboration that includes diverse perspectives helps catch this kind of bias before the innovation is released.
Working with Users: Collaboration also means consulting and communicating with the people who will use the innovation. Information gathered from potential users shows how different people understand the program's purpose and what they need from it, so developers can build a program that fully includes those perspectives. For example, the heart health app team could ask older patients whether the text and buttons are easy to read and tap.
Benefits of Collaboration in Programming:
  1. Skill Enhancement:
      • Group programming allows individuals to pair their strengths with others' weaknesses, leading to a more robust and comprehensive product.
  1. Increased Efficiency:
      • Multiple perspectives can streamline problem-solving processes and introduce innovative solutions faster.
  1. Learning and Development:
      • Collaboration is not just about completing tasks but also about personal growth and development in communication, negotiation, and conflict resolution.
  1. Resource Sharing:
      • Combining different resources and talents from individuals enhances the quality and scope of projects.
  1. Remote Collaboration:
      • Modern tools like Google Docs, Zoom, and Slack enable programmers to collaborate effectively regardless of geographical barriers, ensuring that physical location is no longer a limitation.
      • Programmers also use code-sharing sites like GitHub to share their code, comment on each other's work, and suggest changes.
Collaboration's Impact on Product Development:
The collective experience and expertise of a group often surpass what an individual can achieve alone. This shared knowledge base leads to more creative solutions and innovations, proving that the whole can indeed be greater than the sum of its parts.
Pair Programming: A common model for collaboration. Two programmers share one computer and take on two roles:
  • Driver: Types the code.
  • Navigator: Reviews each line as it's typed, catches mistakes, and thinks about the bigger plan for the program.
The pair switches roles often. Because a second person checks every line, many errors get caught right away, and both programmers learn from each other.
Interpersonal Skills for Effective Teams:
  • Communication: Sharing ideas clearly, listening to teammates, and giving and taking feedback respectfully.
  • Consensus Building: Working toward a decision the whole team can support, instead of one person deciding for everyone.
  • Conflict Resolution: Handling disagreements calmly by focusing on the problem, not the person.
  • Negotiation: Finding a compromise when teammates want different things, like agreeing on which features to build first when there isn't time for all of them.

Understanding Program Functions

A program, often referred to as software, is a collection of statements that instruct the computer to perform specific tasks.
Example of Basic Program Function:
  • Input: Receive the number 3.
  • Task: Determine if the number is even or odd.
  • Output: The program outputs "odd".
This example illustrates how a simple input can be processed to yield a specific output, demonstrating the fundamental operation of a software program.
Working for Many Inputs: A program needs to work for a variety of inputs and situations, not just one. The even/odd program should give the right answer for 3, but also for 10, 0, negative numbers like -7, and very large numbers.
Program Behavior: The behavior of a program is how it functions while it runs (during execution). It's often described by how a user interacts with it. For example: "When the user types a number and clicks Check, the program displays even or odd."
Introduction to Code Segments
A code segment refers to a collection of program statements that collectively perform a specific task within a larger program. In the AP Computer Science Principles exam, students may encounter code both in textual and graphical forms. Here, we will present two examples of simple text-based code segments to demonstrate basic input, process, and output operations.
//Input: A number number ← 9 //Process: Calculating the //square of the number square ← number * number //Output: Display the square //of the number DISPLAY(square)
Big Idea 1: Creative Development
Describing a Program: A program or code segment can be described broadly, by what it does, or in more detail, by what it does and how its statements do it. For the code segment above:
  • Broad: It displays the square of a number.
  • Detailed: It assigns 9 to number, multiplies number by itself and assigns the result (81) to square, then displays square.
The Importance of Collaboration in Debugging
Collaboration in programming is crucial as it brings multiple perspectives to the table, which is especially helpful in identifying and resolving logical errors. A fresh set of eyes can often spot mistakes that a programmer too close to the code may miss. This collaborative effort enhances the debugging process and increases the overall quality of the software.
Program Abstraction
Abstraction in programming allows users to interact with software without needing to understand the underlying details of its operation. This abstraction is essential for simplifying user experiences and focusing on functionality rather than complexity.
Program Inputs: Inputs are data sent to a computer for a program to process. Input can come from a user or from other programs (a weather app gets the forecast from a weather service's program, not from you). It comes in many forms:
  • Tactile: Touch, like tapping a touchscreen, pressing a button, or clicking a mouse.
  • Audio: Sound, like a voice command.
  • Visual: Images or video, like a phone camera scanning a QR code.
  • Text: Typed letters or numbers.
Inputs usually affect the output a program produces. Type a different number into a calculator and you get a different answer.
Example of Program Input
Consider a smart home system that adjusts the lighting based on the natural light input received through sensors:
  • Input: A light sensor measures how bright it is outside. This input comes from a sensor, not from a person typing.
  • Process: The program compares the light level to the brightness the user chose.
  • Output: The lights brighten or dim to match.
Here’s a simple diagram illustrating the input and output process in a typical application:
Big Idea 1: Creative Development
Examples of Input: Keyboard typing, Mouse click, Sensor data
Examples of Process: Data calculation, User command interpretation
Examples of Output: Display information, Sound, Mechanical action
Program Outputs: Outputs are any data sent from a program to a device. Like input, output can be tactile (a phone vibrating), audio (a song playing), visual (a picture on the screen), or text (a message displayed). Output is usually based on the program's input or its prior state, meaning values it has already stored. For example, a step counter displays your total by adding new steps to the count it already saved.
Events: An event is an action that supplies input data to a program. Events are generated when a key is pressed, a mouse is clicked, a program is started, or any other defined action happens that affects the flow of execution.
Event-Driven Programming: In event-driven programming, program statements run when an event triggers them, not just in order from top to bottom (the sequential flow of control). For example, in a game, the code that makes a character jump waits until the player presses the space bar. It runs every time the key is pressed and doesn't run at all if the key is never pressed.
Basic Example of How a Program Uses Input to Trigger an Event
Example: Music Streaming App
  • Input: User selects a song from the playlist.
  • Process: The app receives the selection and retrieves the corresponding audio file from its database.
  • Event Trigger: The audio file is streamed, and the music begins to play through the user’s device.
This example demonstrates how input (song selection) is processed by the app to produce an output (music playback), providing a straightforward illustration of how user interactions can control software behavior.

Understanding the Development Process in Computing

The software development process can be visualized through various stages, each critical to the creation of a functional and user-friendly application. This process can be either orderly and planned or more exploratory, depending on the project requirements.
The Iterative Development Process
There are many development processes, but most use the phases below. A process is iterative when it keeps refining and revising the program based on feedback, testing, or reflection the whole way through, which can mean going back to an earlier phase.
  1. Investigating and Reflecting: Initial research and brainstorming to understand user needs and technical requirements.
  1. Designing: Creating designs and mockups to visualize the application’s layout and functionalities.
  1. Prototyping: Developing a working model of the app to test design concepts and basic functionality.
  1. Testing: Rigorous testing to identify bugs and verify the app meets all functional requirements.
Example of Iteration: After testing, you may discover that additional features are necessary or certain functionalities are not user-friendly, prompting a return to the "Investigating and Reflecting" phase to reconsider these aspects. This cycle might repeat multiple times, refining the application until it meets the desired standards or until development time expires.
The Incremental Development Process
  • Process: This approach involves breaking down the software project into smaller, manageable components or increments. Each part is developed, tested, and finalized before moving on to the next, ensuring that each component functions correctly as part of the whole.
Example of Incremental Development: For a large e-commerce platform, the development could start with user registration and login processes. Once these are fully operational, shopping cart functionalities might be added, followed by payment processing modules. This method helps in isolating and resolving errors more efficiently, simplifying the debugging process.
Iterative vs. Incremental: Iterative development repeats the cycle to keep improving the program. Incremental development builds the program one piece at a time and makes sure each piece works before adding it to the whole. They aren't opposites. Many teams do both: they build in small pieces and keep refining each piece based on feedback.
Understanding the Design Process
The design of a program involves thorough investigation to determine its requirements. Since most programs are intended for users other than the developers themselves, it is crucial to understand not only the technical constraints but also the needs and concerns of the end-users.
Methods for Investigation:
  • User Interviews: Engaging with potential users to gather insights about their needs and preferences.
  • Market Research: Analyzing similar applications to understand common features and user expectations.
  • Feedback Loops: Implementing initial designs with a small group of users to collect feedback and make necessary adjustments.
    • This is also called user testing: having real users try a version of the program to see what confuses them or doesn't work.
  • Surveys: Collecting data from many potential users at once with a set of questions, like asking students which features they would use most.
  • Direct Observation: Watching people do the task the program is meant to help with, to see what they actually do and need.
Program Requirements and Specifications:
Investigation helps developers understand the program's constraints (limits like time, budget, or which devices it must run on) and the concerns and interests of the people who will use it. That leads to:
  • Program requirements: Describe how a program functions, and may include a description of the user interactions the program must provide. For a homework tracker app, two requirements could be "The user can add an assignment with a due date" and "The app sends a reminder the day before it's due."
  • Specification: Defines the requirements for the program. It's the full list of what the program has to do.
The Design Phase:
In a development process, the design phase outlines how to accomplish the program's specification. It may include:
  • Brainstorming: Coming up with lots of possible ideas before choosing which ones to build.
  • Planning and storyboarding: Sketching each screen in order to show what the user sees and does, step by step.
  • Organizing the program into modules and functional components: Breaking the program into parts that each do one job, like a part that saves data and a part that displays it.
  • User interface diagrams: Drawing the layout of each screen, showing where the buttons, text boxes, and images go.
  • A testing strategy: Planning how the program will be tested, including which inputs to try (see Testing a Program below).

Importance of Program Documentation

Program documentation plays a vital role in the development and maintenance of software. It provides a detailed description of what a code segment, event, procedure, or the entire program does, and explains how it was developed.
Benefits of Documentation:
  • Memory Aid: Helps programmers recall their thought processes or decisions made during development.
  • Collaboration Support: Essential in team settings, allowing all members to understand each part of the program.
  • Maintenance and Updating: Facilitates future changes and debugging by providing a clear understanding of the program’s functionality.
Forms of Documentation:
  • Comments: Non-executable text within the code that explains functions, variables, and algorithms. Comments are crucial for maintaining readability and do not impact the runtime or speed of the program.
  • External Documents: These might include requirement specifications, design diagrams, and user manuals, providing broader context and guidelines for using and modifying the program.
When to Document: Programmers should document a program throughout its development, not just at the end. It's much easier to explain a code segment right after writing it than to remember weeks later why it works the way it does.
When Comments Aren't an Option: Not all programming environments support comments. In that case, programmers use other methods of documentation, like a separate document that explains each part of the program.
Example of Using Comments in AP Pseudocode
//This is a comment
Big Idea 1: Creative Development
Program Documentation Practices
Documentation can vary significantly depending on the programming language and the nature of the project. For the AP Computer Science Principles performance task, you have the option to:
  • Inline Documentation: Write comments directly in your code to explain segments, logic, and decisions.
  • External Documentation: If your programming environment doesn't allow comments, you can add them in a document editor when you capture your program code for submission.
No Comments in the Personalized Project Reference: The code screenshots in your Personalized Project Reference can't include any comments or course content. Remove them before taking the screenshots, or the Create task gets a score of 0 (see Create Task: Tips and Resources).
Importance of Flexible Documentation: Adapting your documentation to the specific needs of the project and the preferences of your team or course requirements is essential for clarity and maintainability.
Acknowledging Code from Other Sources
If you use a code segment that someone else wrote, or one you developed together with other people, you need to acknowledge it. Using someone else's code without credit is plagiarism. The acknowledgement can go in the program documentation (usually a comment right above the code) and should include where the code came from or the original author's name. For the Create task's citation rules, see Create Task: Tips and Resources.
// The shuffle procedure below was made freely available by [author's name] on [website] // This code was provided as starter code by my teacher

Types of Program Errors

1. Logic Error:
  • Description: A logic error occurs when there is a flaw in the algorithm that causes the program to operate incorrectly or produce unintended results.
  • Example: This code is supposed to find the average of three test scores. Because of the order of operations, only score3 gets divided by 3, so it displays about 193.33 instead of 80. The program runs without crashing. It just gives the wrong answer. The fix is to add parentheses: avg ← (score1 + score2 + score3) / 3.
score1 ← 90 score2 ← 80 score3 ← 70 avg ← score1 + score2 + score3 / 3 DISPLAY(avg)
2. Syntax Error:
  • Description: A syntax error occurs when the code violates the grammatical rules of the programming language, leading to a failure in compiling or interpreting the code.
  • Example: DISPLAY("Hello" is missing its closing parenthesis. The program won't run until the mistake is fixed, and most programming environments point out syntax errors for you.
3. Runtime Error:
  • Description: A runtime error happens during the execution of the program, often due to operations like division by zero, accessing invalid array indices, or insufficient memory.
  • Each programming language defines its own run-time errors. For example, dividing by zero causes an error in Python, but in JavaScript it gives the special value Infinity and the program keeps running.
  • Example: In AP pseudocode, list indexes start at 1. Using an index less than 1 or greater than the length of the list produces an error message and the program stops. This list has 3 items, but the code asks for item 4:
nums ← [10, 20, 30] DISPLAY(nums[4])
4. Overflow Error:
  • Description: An overflow error occurs when a computer attempts to handle a number that is outside the defined range of values.
  • Example: If a program stores whole numbers in 8 bits, it can only hold values from 0 to 255. Adding 1 to 255 needs a 9th bit, so it causes an overflow error. (Big Idea 2: Data explains how the number of bits limits the range.)

Finding and Correcting Errors

These are effective ways to find and correct errors:
  • Test Cases: Run the program with inputs where you already know the correct output, and compare. A wrong output tells you there's an error and gives you a clue where to look (more in Testing a Program below).
  • Hand Tracing: Go through the code line by line on paper, writing down the value of each variable every time it changes, usually in a table (a trace table).
  • Visualizations: Tools or drawings that show what the program is doing, like a diagram of a list after each step or a tool that animates the code as it runs and shows each variable's value.
  • Debuggers: Software tools that let you pause a program at a chosen line (a breakpoint), run it one line at a time, and check the values of variables at each step.
  • Extra Output Statements: Temporarily add DISPLAY statements that show the values of variables at different points. If a value looks wrong, the error is somewhere before that point. Remove them when you're done.
Hand Tracing Example:
This code is supposed to add the numbers 1 through 4 and display 10.
total ← 0 count ← 1 REPEAT 3 TIMES { total ← total + count count ← count + 1 } DISPLAY(total)
Trace it by writing down total and count after each repeat:
Step
total
count
Start
0
1
After repeat 1
1
2
After repeat 2
3
3
After repeat 3
6
4
The trace shows the program displays 6, not 10, because the loop runs one time too few. Changing REPEAT 3 TIMES to REPEAT 4 TIMES fixes it. An extra output statement would show the same thing: adding DISPLAY(total) inside the loop shows the running total going 1, 3, 6 and stopping there.

Testing a Program

In the development process, testing means running a program with defined inputs (inputs picked ahead of time, with known expected outputs) to make sure it produces the expected outcomes. Programmers use the test results to revise their algorithms or programs, then test again.
Choosing Test Inputs:
  • Start from the requirements: The program requirements tell you what the program should do, so you need them to pick appropriate test inputs and to know the expected output for each one.
  • Test every outcome: Pick inputs that cause each different expected outcome.
  • Test the extremes: Use inputs at the minimum and maximum of the input data, and just beyond them. Errors often show up at these edges.
Example: A grade checker has this requirement: scores from 0 to 100 are valid, a score of 70 or higher displays "Pass", a lower valid score displays "Fail", and any score outside 0 to 100 displays "Invalid".
score ← INPUT() IF(score < 0 OR score > 100) { DISPLAY("Invalid") } ELSE { IF(score ≥ 70) { DISPLAY("Pass") } ELSE { DISPLAY("Fail") } }
Test input
Expected output
Why test it
-1
Invalid
Just below the minimum
0
Fail
The minimum
69
Fail
Just below the passing cutoff
70
Pass
Exactly at the passing cutoff
100
Pass
The maximum
101
Invalid
Just above the maximum
If the programmer had written score > 70 instead of score ≥ 70, the test with 70 would display "Fail" instead of "Pass". That failed test points straight to the logic error, so the programmer fixes the condition and runs all the tests again.

Practice exam

Test yourself on Unit 1: Creative Development

Three exams for this unit in the real AP format, timed, with your score and what to study next. Exam 1 is free.

AP® is a registered trademark of the College Board, which is not affiliated with Dove's Library and was not involved in the production of, and does not endorse, this website.

Providing free, high-quality AP notes to help students succeed, earn college credit, and reach their educational goals, ensuring everyone has access to the resources they need.

© 2026 Standard Learning Group, Inc., which operates Dove's Library. All rights reserved.