Key vocabulary

Building a modular program — the full cycle

Why this lesson is different

Every lesson so far has taught one skill in isolation: one data structure, one construct, one algorithm, one testing idea. This lesson is different — it asks you to run the whole cycle, analysis through evaluation, on one small original problem, exactly as the assignment (Task 1, 25 marks) will require in February–March 2027. The problem is deliberately scoped: it uses functions, procedures, parameter passing, and one standard algorithm — but no arrays of records and no file handling, which are saved for SDD20's second mini-project. Keeping the scope narrow here means the cycle itself, not the data structures, is what gets rehearsed first.

The problem for this lesson

A teacher wants a small program to summarise a class's quiz scores (each out of 100), stored in a single 1D array. The program should calculate the average score, find the highest score, and display a summary — this is deliberately similar in shape to SDD13/14's standard algorithms, but now built as a complete, tested, evaluated modular program rather than a single isolated function.

Stage 1 — Analysis

Analysis identifies the functional requirements before any design or code exists. For this problem: the program must store a set of quiz scores in an array; calculate the average of those scores; find the highest score in the array; and display a clear summary of both results. Each of these becomes a specific requirement that later testing (Stage 4) will need to trace back to — a program that does something extra, or misses one of these four, has not met its functional requirements.

Stage 2 — Design

Design plans the program's shape before implementation. The top-level design for this problem has one main routine calling three sub-programs: calculateAverage (a function, since it returns a value), findHighestScore (a function, returning both the value and its index), and displayResults (a procedure, since it only outputs — it returns nothing). Data flows into the two functions (the scores array) and their results flow into the procedure as parameters. Sketching this on paper first, as a structure diagram or simple pseudocode outline, is what stops a pupil from realising halfway through coding that a value they need in displayResults was never actually passed to it.

Stage 3 — Implementation

Implementation turns the design into working code. calculateAverage reuses SDD7's function pattern (returns a value); findHighestScore reuses SDD14's find-maximum standard algorithm, extended to also track the index of the highest value, not just the value itself; displayResults reuses SDD7's procedure pattern, receiving the average and highest score as actual parameters passed in from the two functions. This is exactly the combination the SQA spec groups together as "computational constructs" (SDD7–SDD12) plus "algorithm specification" (SDD13–SDD15) — this lesson is where those two strands are first required to work together in one program.

Stage 4 — Testing

Testing checks the implemented program against the Stage 1 functional requirements using a structured test plan, not just a single quick run. A complete test plan for this problem needs at least one normal case (a typical mixed set of scores), at least one extreme case (a boundary value, such as the lowest or highest possible score, or every score being identical), and at least one erroneous case (such as an empty array) — mirroring SDD16's three test data categories exactly, now applied to a whole program rather than one function studied on its own.

Stage 5 — Evaluation

Evaluation judges the finished, tested program against all five SDD18 criteria together: does it do what was required (fitness for purpose); does it use appropriate constructs, such as the standard maximum-finding algorithm rather than something more roundabout (efficiency); is its output clear to the teacher using it (usability); are its functions and procedures clearly named and easy to follow (maintainability); and does it cope with situations like an empty array without crashing (robustness). Running this full checklist against a whole modular program, rather than a single isolated function as in SDD18, is genuine rehearsal for the assignment's own evaluation requirement.

Worked examples

1. SET scores TO [62, 78, 45, 91, 55, 70]
2. CALL calculateAverage(scores) storing result in average
3. CALL findHighestScore(scores) storing results in highestValue, highestIndex
4. CALL displayResults(scores, average, highestValue, highestIndex)

examScores = [62, 78, 45, 91, 55, 70]

def calculateAverage(scores):
    total = 0
    for i in range(len(scores)):
        total = total + scores[i]
    average = total / len(scores)
    return average

def findHighestScore(scores):
    highestValue = scores[0]
    highestIndex = 0
    for i in range(1, len(scores)):
        if scores[i] > highestValue:
            highestValue = scores[i]
            highestIndex = i
    return highestValue, highestIndex

def displayResults(scores, average, highestValue, highestIndex):
    print("Number of scores:", len(scores))
    print("Average score:", round(average, 1))
    print("Highest score:", highestValue, "(quiz", highestIndex + 1, ")")

Task Set A — Core questions

def calculateLowestScore(scores):
    lowestValue = scores[0]
    lowestIndex = 0
    for i in range(1, len(scores)):
        if scores[i] < lowestValue:
            lowestValue = scores[i]
            lowestIndex = i
    return lowestValue, lowestIndex

# calculateLowestScore([62, 78, 45, 91, 55, 70]) returns (45, 2)

Task Set B — Extension