Software Design & Development · Unit Review

SDD22 — Unit Review and Test

📅 Mon 5 Oct 2026 · P1+P2 (double)
~120 minutes
Learning intentions
Success criteria
Warm up — the shape of this unit
Answer all three questions, then check your answers.
Question 1
How many lessons make up the full SDD unit (SDD1–SDD22)?
Question 2
Which two lessons rehearsed the full analysis→design→implementation→testing→evaluation cycle on an original problem?
Question 3
Which SQA skill area carries the largest mark range in the question paper (20–40 marks)?

Key vocabulary — one term per strand

Iterative / agile
Development methodologies (SDD1) — cycling back through phases, or working in short customer-facing sprints.
Functional requirement
Analysis (SDD2) — a specific statement of what a program must do, in terms of inputs, processes, and outputs.
Structure diagram
Design (SDD3/4) — a top-level plan of a program's sub-programs and data flow, produced before coding.
Array of records
Data structures (SDD5/6) — a collection of structured items, each with multiple named fields.
Formal / actual parameter
Computational constructs (SDD7–12) — the variable in a function's definition versus the value passed at the call site.
Standard algorithm
Algorithm specification (SDD13–15) — a reusable pattern such as linear search or finding a maximum value.
Normal / extreme / erroneous
Testing (SDD16) — the three categories of test data a comprehensive test plan must include.
Breakpoint / watchpoint
Debugging (SDD17) — tied to a specific line, or tied to a specific variable regardless of line.
Robustness
Evaluation (SDD18) — one of five criteria; whether a program handles unexpected input without crashing.

Reviewing the whole unit

What this lesson is for

This is the final SDD lesson of the course. It introduces no new content — every fact, function, and concept below has already been taught and Python-verified somewhere in SDD1–21. Its purpose is consolidation: confirming that skills from every strand can still be recalled and applied together, not just immediately after the lesson that first taught them, and identifying specific gaps to close before the January prelim.

The coverage map

The SQA content map (§2 of the delivery plan) lists every mandatory strand: development methodologies, analysis, design, data structures, computational constructs, algorithm specification, testing, debugging, evaluation, and the applied cycle. Task Set A below is built directly from this table as a checklist — one question per strand, confirming nothing from the whole unit has been left untested by the time SDD22 finishes. This mirrors exactly how the checklist should be used when auditing any teaching unit for completeness, rather than trusting from memory that "everything's probably covered".

SDD1 Development methodologies
SDD2 Analysis
SDD3–4 Design
SDD5–6 Data structures
SDD7–12 Computational constructs
SDD13–15 Algorithm specification
SDD16 Testing
SDD17 Debugging
SDD18 Evaluation
SDD19–20 Applied cycle

Why revisiting old lessons matters more than it feels like it should

A skill that felt solid immediately after SDD7's lesson on functions and procedures can genuinely fade by the time SDD22 arrives, five weeks and fourteen lessons later — this is a normal feature of memory, not a sign the original teaching failed. Deliberately testing every strand again now, rather than assuming earlier confidence still holds, is exactly why this review exists as its own lesson instead of simply trusting that SDD1–21's individual task sets were enough on their own. It is also why each question in Task Set A below deliberately links back to the specific lesson it came from, rather than being presented as an anonymous mixed quiz — knowing exactly which lesson a wrong answer traces back to is what turns a single test result into something genuinely useful for revision.

How this connects to what comes next

The prelim (historically the first three weeks of January 2027) and the actual question paper (May 2027) will both draw on this entire unit at once, exactly as SDD21's mixed-topic questions began rehearsing. Task Set B's reflection at the end of this lesson is deliberately designed to turn today's specific results into a concrete, prioritised revision plan for the weeks between now and the prelim — a generic feeling of "I should revise SDD" is far less useful than a specific list of which strands actually need the most attention. The same coverage map used to build today's test can be reused later, unchanged, as a personal revision checklist — ticking off each strand once it has been actively revisited, rather than only once it has been taught for the first time.

Worked examples — one strand recapped in full detail

Example 1 — Data structures (SDD5/6): parallel arrays vs records
1
Recap: stockLevels = [30, 45, 20, 15, 60, 18] is a plain 1D array (SDD5); the equivalent array of records (SDD6) is itemRecords, where itemRecords[3].stock accesses the Flapjack record's stock field by name, rather than by matching index across two separate arrays.
Confirmed by an actual Python run: sum(stockLevels)188. This single number can be calculated identically whether the data is stored as a plain array or as an array of records — the choice between the two structures matters for readability and scalability (more fields, more meaning per item), not for whether this particular calculation is possible.
Example 2 — Computational constructs (SDD7–12): the whole strand in one trace
1
A single call demonstrates several SDD7–12 concepts at once: isAffordable(90, 80), where 90 and 80 are actual parameters matched positionally to price and budget (formal parameters, SDD8), and the function itself is defined with local scope (SDD9) around those two parameters.
Confirmed by an actual Python run: isAffordable(90, 80)False (price exceeds budget). Also recapping SDD10's pre-defined functions: int(68.75)68, while round(68.75)69 — the two behave differently, and only one (truncation via int()) is the specific Higher-spec function, not National 5's round().
Example 3 — Testing and debugging (SDD16/17): the same bug, two lenses
1
SDD14's findMinimum bug (initialising smallest to 0 instead of array[0]) is the single example this unit has reused most — confirmed to incorrectly return 0 instead of the true minimum 15 against stockLevels.
Through a testing lens (SDD16), this is a logic error — it runs to completion and produces a wrong result without crashing. Through a debugging lens (SDD17), a watchpoint on smallest would immediately reveal it never updates away from 0 across the whole loop. The same bug supports two different, equally important strands of the spec.
Now you try
Using SDD20's library-book scenario, evaluate its robustness in one sentence, referencing the specific test result that supports your judgement.
⚠️ Common mistakes — examiner feedback
📝 Exam tip

Use today's Task Set A result as a genuine diagnostic, not just a score — note down which specific strand (not just "the ones I got wrong") produced each incorrect answer, since a single wrong answer in "algorithm specification" points to a different revision action than a wrong answer in "evaluation". This turns one test into a specific, actionable prelim revision plan rather than just a percentage.

Task Set A — Unit test

Task Set A — Unit test
One question per strand from the coverage map. Work through all questions, then check your answers.
Question 1 — SDD1, development methodologies
Which best describes agile methodology?
Question 2 — SDD2, analysis
Functional requirements are identified in terms of inputs, processes, and ______?
Question 3 — SDD3/4, design
What is the name of the diagram showing a program's top-level design and data flow?
Question 4 — SDD5/6, data structures
Given stockLevels = [30, 45, 20, 15, 60, 18], state the sum of all six values.
Question 5 — SDD7–9, functions/procedures/scope
isAffordable(90, 80) compares a price of 90 against a budget of 80. What does it return?
Question 6 — SDD10–12, pre-defined functions and file handling
State the result of int(68.75).
Question 7 — SDD13–15, algorithm specification
Given the six-item itemRecords array with a low-stock threshold of 20, state the result of countLowStock(itemRecords, 20).
Question 8 — SDD16, testing
calculateAverage(100, 0) raises ZeroDivisionError. What type of error is this?
Question 9 — SDD17, debugging
For SDD14's findMinimum bug, would a breakpoint or a watchpoint be more directly useful, and why? (3 marks)
Write a function calculateTotalCopies(copies) that returns the sum of all values in an array of book copy-counts, reusing the running-total pattern from SDD5/SDD7.
Question 11 — SDD18/19/20, evaluation and the applied cycle
Evaluate the SDD20 library-book program against all five evaluation criteria, referencing specific evidence from its test plan. (5 marks)

Task Set B — Extension

Task Set B — Extension · Revision planning
Longer written answers — no auto-check. Discuss your answers with your teacher.
Extension 1
Using your own results from Task Set A, write a specific, strand-by-strand revision plan for the weeks before the January prelim.
Extension 2
Given the QP mark ranges in §1 (Design 20–40, Evaluation 0–5), suggest how a pupil should weigh revision time between a strand they found weak in today's test versus one they found strong, if the weak strand also happens to carry more marks.
Extension 3
Which earlier lesson(s) most closely resemble what the actual assignment (Task 1) will require, and why would reviewing those specifically be good assignment preparation?
📁 File this in OneNote under:
Higher Computing Science → Software Design & Development → SDD22
📌 Teacher notes — not for pupils

Double period — final SDD lesson of the course. Every fact reused here (isAffordable, int(68.75), countLowStock, calculateAverage's ZeroDivisionError, findMinimum's bug, readBooks' IndexError) was already Python-verified in its original lesson (SDD8/10/15/16/17/20) — no new facts introduced, consistent with SDD21's approach.

Suggested timing: 5 min warm-up · 10 min notes + coverage map walkthrough (consider projecting the coverage grid and checking it off live against the class's collective confidence per strand) · 20 min Examples 1–3 · 5 min "now you try" · remainder Task Set A as the actual unit test, ideally under timed, individual conditions rather than collaborative — · Task Set B set as homework, directly informing each pupil's personal prelim revision plan.

This lesson completes the entire SDD1-22 sequence. Per CLAUDE.md's coverage-map instruction, every one of the ten SQA strands is represented in Task Set A by design, not by chance — worth reconfirming against §2 of the delivery plan if this lesson is ever revised.

SQA command words covered: identify, state, describe, explain, design, evaluate — the full set introduced across SDD21/22.