Iterative Development

Iterative development means building a program in repeated cycles, each one improving on the last. You start with a prototype, test it, gather feedback, and revise, then do it all again. Each loop produces a better version.

This is how professional software is made, and it is the natural conclusion of Big Idea 1: Creative Development. The problem-solving, design, abstraction, and testing skills from earlier topics all come together here.

Iterative development replaces the impossible goal of "build it perfectly the first time" with a realistic loop:

• Prototype: build a simple working version of the core idea.
• Test: check that it behaves correctly, including edge cases.
• Feedback: let real users try it and tell you what works and what does not.
• Revise: make focused improvements based on what you learned.
• Improve and repeat: add the next feature and loop again.

Each cycle adds value while keeping the program working. Crucially, you add features incrementally, testing old behavior each time so new changes do not quietly break what already worked.

Visual Iteration Cycle

Add supporting image in static folder

The development loop: Prototype → Test → Feedback → Revise → Improve → Repeat.

This loop never truly ends; it just produces better versions each time around. Read it as a spiral rather than a circle: each pass leaves the program more capable than before. On the exam, recognize that iteration is ongoing and feedback-driven, not a single polish step at the end.

• Iterative development: building and improving a program through repeated cycles.
• Prototype: an early, simplified working version used to test and gather feedback.
• Iteration: one full pass through the build-test-revise cycle.
• Refinement: making targeted improvements to existing behavior or design.
• Feedback: input from users or testing that guides the next iteration.
• Incremental development: adding features a little at a time while keeping the program working.

Be ready to:

• Explain why programs are developed iteratively rather than all at once.
• Identify how user feedback drives the next round of changes.
• Recognize the value of incremental feature development with testing along the way.
• Describe how a program improved from one version to the next.

The Create Performance Task directly rewards describing your development process, including how you identified and fixed difficulties along the way. Iteration gives you that story.

A student builds a quiz app and improves it over three iterations:

• Version 1: asks questions and shows a final score. This is the prototype, the smallest version that proves the core idea works.
• Version 2: after testing, the student adds feedback for wrong answers so users learn from mistakes. Existing scoring is retested to confirm it still works.
• Version 3: based on user feedback, the app now stores progress and recommends review topics, making it genuinely useful for studying.

Each version is complete and working, just less capable than the next. The student never tried to build Version 3 first. That would have been overwhelming and hard to test. Instead, each iteration added one meaningful improvement and confirmed the earlier features still worked.

• Building the final version immediately. Skipping prototypes leads to overwhelming, hard-to-test code.
• Ignoring feedback. Iteration without listening to users is just busywork.
• Adding features without testing old ones. New code can silently break what already worked.
• Changing design without a reason. Revisions should respond to real problems or feedback, not whims.
• Not documenting improvements. If you cannot describe how the program improved, you lose easy Create Task points.

Each time you change your program, write one or two lines: what you added, what problem it solved, and how you tested it. This log becomes the backbone of your written responses on the Create Performance Task, where you must describe how your program developed and how you overcame difficulties.

You have now completed Unit 1: Creative Development. You can analyze problems, design programs, use abstraction, test and debug, and improve software through iteration. These are the habits of a real developer.

In Unit 2: Data, you will explore how computers represent, store, and process information, from binary and text to large datasets. The clear-thinking and problem-solving foundation you built here will help you reason about data with confidence.