Teaching Justify the Code: Control Structures & Efficiency in Grades 9-10 (Level 1): Oklahoma Standard L1.AP.C.01

Teaching control structures efficiency in grades 9-10 (level 1) does not have to be complicated. Picture a mobile app developer choosing a memory-lean loop structure to avoid draining a phone's battery. That kind of thinking is exactly what Oklahoma's grades 9-10 (level 1) computer science standard L1.AP.C.01 asks students to practice — and it is very teachable with the right materials. This post walks through what the standard means, the misconceptions students bring to it, and discussion starters you can use tomorrow, whether you teach in a classroom or at your kitchen table.

What Does Standard L1.AP.C.01 Actually Ask?

Justify the selection of specific control structures (e.g., sequence, conditionals, repetition, procedures) considering program efficiencies such as readability, performance, and memory usage. — Oklahoma Academic Standards for Computer Science (February 2023)

In plain language: This standard asks Level 1 students (grades 9-10) to explain, with real reasoning, why they chose a particular way of structuring their code, weighing how easy it is to read, how fast it runs, and how much computer memory it uses.

In student-friendly terms, the learning target is: "I can justify the selection of specific control structures — sequence, conditionals, repetition, and procedures — by weighing readability, performance, and memory usage."

What Students Should Be Able to Do

• I can identify sequence, conditionals, repetition, and procedures, including nested combinations, in a piece of code.
• I can explain how a control-structure choice affects readability, performance, and memory usage.
• I can name a genuine tradeoff between two competing control-structure approaches to the same task.
• I can write a justification for a control-structure choice that names a specific efficiency and explains why it matters for that task.

Along the way, students pick up the working vocabulary of the topic: sequence, conditional, repetition, procedure, efficiency, readability, performance, memory, variable, nested, tradeoff, pseudocode, optimization.

Control Structures Efficiency: Misconceptions to Watch For

These are the wrong turns students reliably take with this standard — knowing them ahead of time is half the lesson plan. Each correction strategy below comes straight from the unit's teacher guide (the paragraph and activity references point into the unit itself).

1. "Correct code is automatically the most efficient code."

Return to paragraph 6. Correctness and efficiency are separate questions — a program can produce the right answer while still being slow, hard to read, or memory-heavy compared to an equally correct alternative.

2. "The fastest possible code is always the best choice, no matter the task."

Point back to paragraph 3's discussion of a single script versus a game's core loop. How much performance a task actually needs depends on how often that code runs and how visible any delay would be.

3. "Readability is just a style preference, not a real efficiency."

Revisit paragraph 2's passing-grade procedure example. Readability directly affects how quickly errors are found and how safely a program can be updated by a team, not just how 'nice' the code looks.

4. "Nested loops and deeply nested conditionals are always necessary to solve complex problems."

Emphasize paragraph 7's point that unnecessary nested structures often hide in plain sight and can sometimes be eliminated by restructuring the data, such as sorting a list first.

Discussion Starters You Can Use Tomorrow

• Think of an app you use daily that feels either very fast or very slow. What control structure do you think might be responsible, and why?
• Why might a programmer deliberately choose the 'less efficient' option in one specific way, such as using more memory, to gain an advantage somewhere else?
• Describe a real-world task where readability would matter more than raw performance, even if a faster but messier solution existed.

Bringing It Home

This topic is a natural one for families. One ten-minute activity to try: Together, pick a repeated task your family does — packing lunches, checking the mail, watering plants — and describe it out loud as a set of steps. Ask your student to point out which parts repeat (a loop), which parts depend on a decision (a conditional), and whether writing the steps more simply would make them easier for someone else to follow, even if it took a little longer. There are no wrong answers — the goal is hearing their reasoning.

Where This Leads

Students who can justify the selection of specific control structures — sequence, conditionals, repetition, and procedures — by weighing readability, performance, and memory usage are building skills used every day in software engineering, mobile app development, game development, and embedded systems engineering.

See the Unit in Action

Get the Complete L1.AP.C.01 Unit

I built a complete, no-prep unit for this standard — Justifying Control Structures: Writing Code That Is Fast, Clear, and Lean — covering 3-4 days of instruction across 43 pages:

• Teacher guide — day-by-day pacing, misconceptions to watch for, discussion questions, differentiation for support / ELL / extension, and a 4-point rubric
• Student learning target page — a kid-friendly "I can" statement with success criteria
• Full content lesson with 3 embedded "Check Your Understanding" checkpoints
• 12-question assessment (6 multiple choice, 4 true/false, 2 short answer) with a complete answer key, explanations, and exemplar responses
• Group activity — "Justify the Choice: The Control Structure Debate" (25-30 minutes)
• Individual activity — "My Control Structure Justification Log" (20 minutes)
• Crossword and word search built from all 13 vocabulary terms (with answer keys)
• Family connection letter — a plain-language page for parents, with dinner-table questions and a 10-minute home activity
• Certificate of achievement — ready to sign and send home
• Scenario Card Set: Justify the Choice (separate printable, 2 pages)
• Reference Sheet: Justifying Control-Structure Choices (separate printable, 2 pages)
• My Control Structure Justification Log (separate printable, 2 pages)

Get Justify the Code: Control Structures & Efficiency on Teachers Pay Teachers →

Also aligned to CSTA 3A-AP-17: Design and iteratively develop programs that combine control structures, including nested loops and compound conditionals.

Every Sooner Standards resource is built directly from the official Oklahoma Academic Standards for Computer Science (February 2023) — standard text verified, never paraphrased from memory.