AP CSP Topic 1.3 Guided Notes - Program Design and Development
Big Idea 1: Creative Development · Topic 1.3 · Guided Notes (Student)
Program Design and Development — Guided Notes
Fill these in during class or catch up here if you were absent. Print this page or work on paper — then check yourself with the CFUs on the Topic 1.3 page.
Print these notesTopic 1.3 lesson pageAll CSP topics
Day 1: Nobody Great Codes First
Today’s objectives
- Describe how a development process works — its four phases — and tell iterative from incremental (LO CRD-2.E)
- Explain how a program and its interface are designed: investigation, requirements, specification (LO CRD-2.F)
Bell ringer
Your club is running a bake-sale stand at Friday's game, and you're in charge. List the first six things you would do — in order — between right now and the moment the stand opens.
Now go back and label each step with your own one-word tag for what KIND of step it is: finding-out? planning? building? checking? Keep the list — we'll use it all period.
01. How Programs Get Built
Key Vocabulary (LO CRD-2.E)
| Term | Definition (write it) |
|---|---|
| Development process | |
| Iterative development | |
| Incremental development |
Two Styles, Four Phases
- Not every team plans everything up front — the CED also allows a process that is .
- After investigating and reflecting, the remaining three phases are .
- The phases are commonly used, not a mandatory one-way sequence — real processes .
Iterative vs. Incremental — Loops vs. Pieces
Iterative
Incremental
- What sends an iterative team back to an earlier phase?
- The incremental safety rule: never add a piece to the whole until .
- Memory hook: iterative = ; incremental = .
AP TIP: Iterative = LOOPS (revise, revisit earlier phases). Incremental = PIECES (verify each part before adding it). A process can be both at once.
Watch out — “Iterating Means You Failed”
Myth: Going back to an earlier phase means the team messed up — a good developer designs it right the first time and never has to revise.
Explain why this is wrong:
Stop and think
- A team builds a chat app one feature at a time — messages first, verified working, then emojis, then photos, each verified before it joins the app. Iterative, incremental, or both? Defend your label with the CED definition.
- After user testing, a team leaves the code alone but returns to the design phase to rework two screens. Which term describes this — and why is revisiting a phase NOT evidence of failure?
- A programmer facing a brand-new kind of problem starts experimenting with no fixed plan. Which kind of development process is this, and is it legitimate?
Answer in complete sentences. Then check yourself with the matching CFUs on the Topic 1.3 page.
02. Design: From Investigation to Blueprint
Key Vocabulary (LO CRD-2.F)
| Term | Definition (write it) |
|---|---|
| Investigation | |
| Program requirements | |
| Program specification |
The Design Pipeline
- Design starts with investigation because you cannot list what a program must do until .
- Investigation looks outward at .
- Specification vs. design phase: one , the other — in that order.
How You Investigate vs. What Design Produces
Investigation methods
Design-phase activities
- Beyond surveys and user testing, the CED's other two investigation methods are .
- Watching users in their real environment without your product is ; watching them try your product is .
- The design-phase activity students most often forget: developing a .
AP TIP: 'Watching users in their normal routine' = direct observation. 'Watching users try your product' = user testing. Exam items hinge on that difference.
Sort the Activities into Phases
A student team builds a flashcard app. Name the development-process phase for each activity in their week.
Complete the empty cells.
| Team activity | What the team is really doing | Phase |
|---|---|---|
| Survey the 9th grade about what a study app should do | Collecting data from future users to determine requirements | |
| Sketch every screen on paper and storyboard the flow between them | Outlining how to accomplish the specification | |
| Build a rough version where only the login screen actually works | Creating an early working model to try the idea out | |
| Give the rough version to five students and note where they get stuck | Checking the program against user needs; gathering feedback | |
| After the feedback, return to the paper sketches and rework two screens | Revisiting an earlier phase based on feedback — the iterative move |
Stop and think
- A team wants to build an app for the school library but has never spoken to the librarian. Choose TWO investigation methods for them, and say what each would reveal that the other wouldn't.
- In one sentence each: what do the requirements describe, and what does the specification do to those requirements?
- A teammate says the design phase is 'just drawing what the app looks like.' List three OTHER design-phase activities from the CED that prove them wrong.
Answer in complete sentences. Then check yourself with the matching CFUs on the Topic 1.3 page.
Deep Dive · Beyond the AP Exam
Deep Dive: Waterfall vs. Agile
Waterfall (ordered, one pass)
Agile (iterative + incremental)
- Waterfall completes each phase once and never .
- Agile is the CED's two adjectives run as a schedule: .
Deep-dive connection: agile teams iterate BECAUSE testing keeps teaching them things design couldn't predict — as a business model.
Today in one box
- A development process can be ordered and intentional or exploratory; four phases are commonly used: investigating and reflecting, designing, prototyping, testing
- Iterative = loops (refine and revise, revisit earlier phases); incremental = pieces (verify each before adding it to the whole)
- Investigation — surveys, user testing, interviews, direct observations — determines requirements
- The specification defines the requirements; the design phase outlines how to accomplish it: brainstorming, storyboarding, modules, UI diagrams, testing strategy
Before next class: Before tomorrow, chew on this: in June you wrote the most brilliant program of your life. In September you open the file — and you can't read your own code. Nothing is broken. Every line still runs. So what, exactly, went wrong?
Day 2: The Note You Leave for Future You
Today’s objectives
- Describe the purpose of a code segment or program by writing documentation — and explain why comments never affect how a program runs (LO CRD-2.G)
- Acknowledge code segments used from other sources correctly — origin or author's name, in the program documentation (LO CRD-2.H)
Bell ringer
The June mystery, solved by you: in June you wrote a 300-line program — your best ever. In September you open it and find variables named x, temp2, and stuff, no notes of any kind, and you cannot follow your own logic. Every line still runs perfectly.
Write 3–4 sentences: what exactly went wrong, if nothing is broken? Then list three specific things June-you could have left behind that would rescue September-you.
01. Documentation: Writing for Humans
Key Vocabulary (LO CRD-2.G)
| Term | Definition (write it) |
|---|---|
| Program documentation | |
| Comment |
Document Throughout — Not at the End
- Programmers should document a program its development.
- Documentation pays off later: it helps whoever maintains the program keep it .
- When an environment doesn't support comments, .
Watch out — “Comments Slow the Program Down”
Myth: Comments are extra lines the computer has to wade through, so a heavily commented program runs slower — serious programmers strip comments to make code fast.
Explain why this is wrong:
Stop and think
- Using the word 'documentation,' explain precisely what June-you failed to do — and name the TWO audiences every program has.
- A teammate wants to delete all comments before submission 'to speed the program up.' In two sentences, explain what will and won't change, citing what comments are for.
- Your little cousin's block-based coding app has no comment feature. Give two other methods their team could use to document the program — and explain why 'no comments possible' doesn't mean 'no documentation needed.'
Answer in complete sentences. Then check yourself with the matching CFUs on the Topic 1.3 page.
02. Credit Where Code Is Due
What Needs Credit vs. What Credit Requires
What must be acknowledged
What the credit requires
- You must acknowledge any code segment that was .
- A sufficient acknowledgement must state .
- Renaming variables in borrowed code .
AP TIP: Sufficient acknowledgement = IN the documentation + origin or author's name. Both parts, every time — 'I changed it a little' is not a third option.
The Create PT Rule: Credit or Zero
- On the Create PT, uncredited use of others' work or generative AI = .
- Generative AI is permitted as a supplementary resource, but its code must be .
- The habit that makes credit automatic: write the acknowledgement .
Is the Credit Enough?
Four borrowed-code scenarios, one standard: credit in the documentation, naming the origin or author.
Complete the empty cells.
| Scenario | Acknowledgement given | Sufficient? Why / why not |
|---|---|---|
| Your program is built on starter code the teacher gave the whole class | A comment at the top: 'Built on the class starter project provided by the teacher' | SUFFICIENT — the origin is named, in the program documentation |
| You adapt a 10-line code segment from an online API tutorial | None — 'I rewrote the variable names, so it's basically mine now' | |
| A generative AI tool writes your sorting procedure for the Create PT | A comment naming the AI tool as the source — and you can explain how the procedure works | |
| A friend sends you a working code segment and you paste it in | You thank the friend in a text message that night |
Stop and think
- State the two things a sufficient acknowledgement requires, per the CED — the place it lives and the content it includes.
- A classmate says: 'The Create PT allows AI now, so I can just have it write my procedures.' What TWO obligations did they skip, and what does each one cost?
- Your partner wrote half the procedures in your shared program. Nothing was 'copied' from anywhere. Does anything need acknowledging? Exact trigger.
Answer in complete sentences. Then check yourself with the matching CFUs on the Topic 1.3 page.
Deep Dive · Beyond the AP Exam
Deep Dive: How the Pros Document
Inside the code
Around the code
- Two documentation layers at real companies: inside the code (comments, docstrings, names) and .
- Commit messages quietly satisfy the documentation definition because they record .
Deep-dive connection: says documentation describes function AND how it was developed — commit messages are literally that second half, automated.
Common AP Traps
Three ways Topic 1.3 loses points on the exam — one minute now, real points in May.
Iterative vs. incremental swap — in your own words:
Specification ← requirements — in your own words:
The acknowledgement bar — in your own words:
Program Design and Development, in One Slide
- Development processes: ordered-and-intentional or exploratory; four common phases — investigating and reflecting, designing, prototyping, testing
- Iterative = loops (refine, revise, revisit phases); incremental = pieces (verify each before adding to the whole)
- Design pipeline: investigation (surveys, user testing, interviews, direct observations) → requirements → specification defines them → design phase outlines how
- Documentation describes function and development; comments are for people and never affect execution; document THROUGHOUT — even where comments aren't supported
- Credit borrowed code in the documentation with origin or author's name — on the Create PT, uncredited work or AI = score of 0
Exit check — I can…
- ☐ run a development process and tell iterative from incremental (LO CRD-2.E)
- ☐ trace investigation → requirements → specification → design (LO CRD-2.F)
- ☐ write documentation that helps the next person — including future me (LO CRD-2.G)
- ☐ credit borrowed and AI code the way the Create PT requires (LO CRD-2.H)
Get in Touch
Whether you're a student, parent, or teacher — I'd love to hear from you.
Just want free AP CS resources?
Enter your email below and check the subscribe box — no message needed. Students get daily practice questions and study tips. Teachers get curriculum resources and teaching strategies.
Message Sent!
Thanks for reaching out. I'll get back to you within 24 hours.
Prefer email? Reach me directly at [email protected]