Lesson 4 of 82 in this sequence

Not completed yet

Saved on this device only — not synced to an account yet.

Learning path

Step 4 of 82

Continue the sequence

ResumeReturn to this step ReviewRevisit the core idea RemediateGet repair practice Next stepChoose the next lesson manually

Completion

Review objectives and instruction
Complete the activity with manual learner confirmation
Answer every understanding-check item
Show completion feedback and reward only after the learner finishes the check

Progress

Step 4/82
15 content types
AI help source context available
Auto-advance blocked

Review objectives and instruction

AI help

Available only with source grounding, privacy limits, age controls, and measurement.

AI source context

Building an Interactive Guessing Helper: Integrate Four Program-Building Skills · Program synthesis: integrating decomposition, algorithm sequencing, selection control structures, and systematic testing into one working interactive program — CSTA 2-AP-10 (decomposition), 2-AP-11 (algorithm sequencing), 2-AP-12 (selection control structures), 2-AP-17 (systematic testing and debugging) · CSTA 2-AP-10: Decompose problems and subproblems into parts to facilitate the design, implementation, and review of programs · CSTA 2-AP-11: Create clearly named variables that represent different data types and perform operations on their values; sequence steps of an algorithm

Evidence: local lesson AI-help metadata only; source-grounding, privacy, age-safety, and measurement hooks do not prove real model quality, production telemetry, child AI approval, or AI tutor production readiness

Production AI readiness not claimed

AI source context

Assessment shape

Local lesson assessment shape is complete.

Local shape only; production answer-attempt telemetry, live ownership/RLS evidence, mastery interpretation, release, and production readiness are not claimed here.

Objectives: 3
Activity: Prompt ready
Quiz items: 4 items, 4 answer keys, 4 explanations
Reward: Completion reward ready

Assessment progress stays manual: do not auto-advance through uncertain answers, failed writes, consent, media, payment, learner choice, or AI-assisted checks.

Learning-loop evidence: Content-map contract only; persistence and production learner-progress writes require route/API evidence.

Manual policy: assessment, media, consent, payment, learner choice, failed writes, and AI-uncertain help stay under learner control.

Prerequisite: Complete or review Breaking Big Problems Down with Decomposition

AI guardrails

Privacy

Do not send raw child free text without consent
Use source excerpts and non-identifying progress state only
Asset is not registry-gated

Age safety

Apply learn audience controls before AI-help claims
Keep child learner AI paths behind guardian/product review evidence before readiness claims

Measurement

Log AI help usage by surface and asset slug
Evaluate answer quality against source-grounded rubric before production-readiness claims
Tie remediation prompts to completion, retry, or review outcomes

Local AI-help guardrails only; they do not prove guardian approval, production telemetry, model evaluation, release, deployment, or AI tutor production readiness.

Source and rights

Source path: koydo-app/scripts/curriculum-authoring
License: ai-generated-koydo
Attribution: Attribution decision needs owner review
AI provenance: claude-opus-4-8

Source review gates: attribution_missing

Local source evidence only; this does not prove publication rights, attribution approval, AI provenance clearance, release, deployment, or production readiness.

Route review

Current route: /library/learn/computer_science/en/lesson/building-an-interactive-program
Route source: Fallback route needs owner canonical review
Candidate route: /library/learn/computer_science/en/lesson/building-an-interactive-program

Local route evidence only; fallback candidates need owner-approved canonical route policy before route writes, production discoverability, or readiness claims.

Content gates: canonical_target_web_missing_uses_library_fallback

lessonslessonslesson objectivesmedia scenesdrillspractice setsquizzesfeedbackcharacterscitationsconcept mapsprogressresumereviewremediationnext steps

Building an Interactive Guessing Helper: Integrate Four Program-Building Skills

with Byte

Byte, a friendly glowing robot guide, stands at a bright workshop bench and slots the final puzzle piece — a test checklist — into a glowing flowchart on the big screen, completing the full program blueprint

Apply decomposition, algorithm sequencing, selection control, and testing together to build one working interactive program
Trace how each of the four skills hands off to the next skill in the program-building process
Identify which skill to return to when a bug is found, using the program-building order as a repair map

Key terms

Decomposition: Splitting a big goal into small, solvable jobs
Selection structure: An if / else if / else block that picks one branch to run
Branch: One possible path through a selection structure
Test case: A specific input chosen to exercise part of a program
Logic bug: A running program that produces the wrong output

How the Four Skills Hand Off

The four skills are not separate hobbies; each one produces what the next one needs. Decomposition produces a list of small jobs, which become the lines of your algorithm. The ordered algorithm becomes the blueprint you translate into a selection structure. The finished code becomes the thing you test. When a test fails, you do not start over; you follow the chain backward to the exact link that produced the fault, usually a single step in the algorithm, and repair only that.

Covering Every Branch When Testing

A selection structure that has three outcomes hides three separate paths through the code, and a bug can live quietly on any path you never run. Testing only with the exact secret number proves the 'correct' branch works while leaving 'too low' and 'too high' completely unchecked. Choosing one input that triggers each branch — a low guess, a high guess, and the exact number — forces every path to execute at least once, so a wrong comparison cannot stay hidden until a real user stumbles onto it.

Worked examples

Trace the helper with secret 50 and guess 30

The program reads the guess, which is 30.
First check: is 30 equal to 50? No, so skip the 'correct' branch.
Next check: is 30 less than 50? Yes, so this branch runs.
The program prints 'too low' and the other branch is skipped.

Answer: It prints 'too low'

Locate the bug when 'too high' prints 'too low'

Pick an input that should print 'too high', such as guess 80 with secret 50.
Run it and confirm the wrong message 'too low' appears.
Open the algorithm and read the comparison for the high branch.
The step uses 'less than' where it should use 'greater than', so fix only that comparison.

Answer: A reversed comparison step in the algorithm

Hi, I'm Byte! You already know the four building skills: decompose, sequence an algorithm, code a control structure, and test and debug. Today you use all four together on one real program — a guessing helper that tells the user if their number is too low, too high, or correct. Watch how each skill feeds the next. First, DECOMPOSE: split the big goal into small jobs — get a number from the user, compare it to the secret, print the right message. Now you have clear pieces. Second, SEQUENCE the ALGORITHM: write those pieces in order, in plain words. Order matters — you cannot compare before you have a number. Third, CODE a SELECTION STRUCTURE: turn your algorithm into an if / else if / else block. The selection structure is what makes the program choose between 'correct,' 'too low,' and 'too high.' One choice at a time, no guessing. Fourth, TEST and DEBUG: run the program with a low guess, a high guess, and the exact secret number. Every branch should fire. If 'too high' prints 'too low,' that is a comparison bug — go back to your algorithm, find the wrong step, and fix only that step. The four skills form a loop, not just a line: a bug found in testing sends you back to the right spot in the algorithm, not to the beginning. That is the repair map. If you feel lost at any point, name which of the four skills you are on — that always gives you your next move.

Activity

Put these four program-building moves in the correct order, from first to last

Practice

List the three small jobs you would decompose the guessing helper into.

Choose three test inputs that exercise every branch of the helper.

Common mistakes to avoid

A wrong output means a hardware failureA program that runs but prints the wrong message has a logic bug, not a broken computer.
Skipping decomposition saves timeSkipping it usually causes missing or mis-ordered steps that are hard to find without a written algorithm.

Check your understanding

A program should print 'too high' when the guess is bigger than the secret number, but it prints 'too low' instead. What is the best first step?

In the guessing helper, which control structure lets the program choose among 'correct', 'too low', and 'too high'?

Why must you test the guessing helper with a low guess, a high guess, AND the exact secret number — not just one input?

A student skips decomposition and tries to write the if / else if / else code directly from the goal sentence. What is the most likely problem?

Recap

Building an interactive program chains four skills: decompose into jobs, sequence them into an algorithm, code a selection structure, and test every branch. A failing test sends you back to the exact algorithm step, forming a repair loop rather than a restart.

Reflect

Which of the four skills do you tend to rush, and what could that cost you?