Programming Fundamentals

Software Development Steps

🎯 (SE-11-01)

📌 Explore fundamental software development steps used by programmers when designing software

• requirements definition
• determining specifications
• design
• development
• integration
• testing and debugging
• installation
• maintenance

A mini-project through the steps

Reading the eight steps is easier once you watch one small project pass through all of them. A school canteen asks for a program that totals a lunch order. Follow the canteen order calculator from the first interview to the first patch.

The design step for this project produces an uncluttered mainline. Notice that it names each subroutine and shows only the order they run in.

BEGIN Mainline
    GetOrder (items, total)
    ApplyDiscount (total, items)
    DisplayTotal (total)
END Mainline

The development and integration steps turn that design into Python. Each subroutine is written and tried on its own, then main joins them.

DISCOUNT_ITEMS = 10          # orders this size or larger get a discount
DISCOUNT_PERCENT = 10

def read_whole_number(prompt):
    """Keep asking until the user types a whole number of 0 or more."""
    while True:
        text = input(prompt)
        if text.isdigit():
            return int(text)
        print("Please enter a whole number of 0 or more.")

def get_order():
    items = 0
    total = 0                    # cents
    price = read_whole_number("Price in cents (0 to finish): ")
    while price != 0:
        quantity = read_whole_number("Quantity: ")
        items = items + quantity
        total = total + price * quantity
        price = read_whole_number("Price in cents (0 to finish): ")
    return items, total

def apply_discount(total, items):
    if items >= DISCOUNT_ITEMS:
        return total - total * DISCOUNT_PERCENT // 100
    return total

def format_dollars(cents):
    return f"${cents // 100}.{cents % 100:02d}"

def main():
    items, total = get_order()
    total = apply_discount(total, items)
    print("Total:", format_dollars(total))

main()

During testing and debugging, a run with six items at 450 cents and four items at 300 cents gives:

Price in cents (0 to finish): 450
Quantity: 6
Price in cents (0 to finish): 300
Quantity: 4
Price in cents (0 to finish): 0
Total: $35.10

Check it by hand: 6 × 450 + 4 × 300 = 3900 cents; ten items qualify, so 390 cents come off, leaving 3510 cents, which displays as $35.10. The same program is used again in the testing sections of this page to show boundary, path and abnormal test data.

Why the steps form a cycle

The steps are drawn in order, but real projects loop. A test failure sends the team back to development, a design flaw found during integration sends them back to design, and maintenance requests become the requirements for the next version. The flow is a cycle, not a one-way street. The SDLC Guide compares this ordered view with Waterfall and Agile, which are covered later on this page.

Online Code Collaboration Tools

🎯 (SE-11-03, SE-11-06)

📌 Research and evaluate the prevalence and use of online code collaboration tools

Almost every software team now shares its code online. Tools such as GitHub, GitLab and Bitbucket store a project's code in a shared repository and track every change, so people in different places can work on it at once. GitHub is used by many millions of developers, and a large share of open-source projects live there.

Evaluating collaboration tools

Prevalence and use

Online code collaboration tools are now the normal way teams share code, from a two-person school project to a large open-source product. They are used to store the code, keep its history, review changes, track bugs and run automated checks. Students meet them in the same way: a shared repository for a group project, with each person working on their own branch.

A typical workflow

Most teams follow the same loop: copy the repository, make a branch, commit small changes, push the branch and ask for a review. Here is the loop as Git commands, with what each does.

git clone https://github.com/example-team/canteen-app.git   # copy the shared repository to your computer
git checkout -b add-teacher-discount                        # start a new branch so main stays stable
# ... edit apply_discount() and test it ...
git add canteen.py                                          # choose the changed file for the next commit
git commit -m "Add 15% teacher discount"                    # save a snapshot with a message
git push origin add-teacher-discount                        # upload the branch, then open a pull request

On the platform, a teammate reads the pull request, comments on lines they question and approves it. Automated tests can run on every pull request, so a change that breaks the tests is caught before it is merged.

Resolving a merge conflict

A merge conflict happens when two branches change the same lines. Git cannot decide which version is right, so it marks both in the file and waits for a person to choose.

def apply_discount(total, items):
<<<<<<< HEAD
    if items >= 10:
=======
    if items >= 8:
>>>>>>> add-teacher-discount
        return total - total * 10 // 100

Everything between <<<<<<< HEAD and ======= is the version on the current branch; everything down to >>>>>>> is the incoming version. The developer keeps one version (or combines them), deletes the marker lines, tests, then commits. Talking to the teammate first is often faster than guessing which threshold is right.

Evaluating a tool for your team

Key Features of Standard Algorithms

🎯 (SE-11-02)

📌 Apply computational thinking and algorithmic design by defining the key features of standard algorithms, including sequence, selection, iteration and identifying data that should be stored

Every algorithm uses fundamental building blocks to solve problems. Understanding these features allows programmers to design robust, efficient solutions:

1. Sequence

Sequence means instructions are executed in order, one after another. Each step completes before the next begins — there is no branching or repetition.Reading a file, processing each line, then saving results.

BEGIN
    OUTPUT "Enter the length: "
    INPUT length
    OUTPUT "Enter the width: "
    INPUT width
    area ← length * width
    OUTPUT "The area is: ", area
END

2. Selection

Selection means choosing different execution paths based on conditions using IF … ELSE, nested IF or a multi-way CASEWHERE structure. The program evaluates a condition and branches accordingly.Validating user input — if age < 18, display "Too young"; otherwise, proceed.

BEGIN
    OUTPUT "Enter your age: "
    INPUT age
    IF age >= 18 THEN
        OUTPUT "Welcome!"
        ShowFullMenu ()
    ELSE
        OUTPUT "Too young - access denied."
    ENDIF
END

Two more selection forms appear in NESA’s Course Specifications. Multi-way selection chooses one of several cases by evaluating a single expression, and only one branch runs. It is written CASEWHERE … OTHERWISE … END CASE.

CASEWHERE menuChoice evaluates to
    1: OUTPUT "New game"
    2: OUTPUT "Load game"
    3: OUTPUT "High scores"
    OTHERWISE: OUTPUT "Invalid choice"
END CASE

Nested IF tests several conditions in turn when only one process should run. Each further test is a complete IF indented inside the ELSE of the one before it, and every IF has its own ENDIF.

IF mark >= 85 THEN
    OUTPUT "High"
ELSE
    IF mark >= 65 THEN
        OUTPUT "Medium"
    ELSE
        IF mark >= 50 THEN
            OUTPUT "Pass"
        ELSE
            OUTPUT "Fail"
        ENDIF
    ENDIF
ENDIF

3. Iteration

Iteration means repeating a set of instructions while a condition is true, using FOR or WHILE loops. The loop body executes multiple times until the exit condition is met.Summing all numbers in a list by looping through each element.

BEGIN
    numbers ← [10, 25, 3, 47, 8]
    total ← 0
    FOR i = 0 TO LENGTH(numbers) - 1
        total ← total + numbers[i]
    NEXT i
    OUTPUT "The sum is: " + total
END

NESA describes three loops. WHILE is a pre-test loop, so its body may never run. REPEAT … UNTIL is a post-test loop, so its body always runs at least once, which suits input validation. FOR … NEXT is a counted loop; STEP sets the increment and can be negative.

REPEAT
    OUTPUT "Enter a mark from 0 to 100: "
    INPUT mark
UNTIL mark >= 0 AND mark <= 100

FOR i = 1 TO 10 STEP 2
    OUTPUT i
NEXT i
// Output: 1 3 5 7 9

4. Storing Data

Storing Data means using variables and data structures to hold values needed across multiple steps of an algorithm. Without stored state, programs cannot track progress or accumulate results.Keeping track of a running total as you iterate through numbers.

BEGIN
    runningTotal ← 0
    count ← 0
    OUTPUT "Enter numbers (-1 to finish): "
    INPUT number
    WHILE number != -1
        runningTotal ← runningTotal + number
        count ← count + 1
        INPUT number
    ENDWHILE
    IF count > 0 THEN
        average ← runningTotal / count
        OUTPUT "Average: " + average
    ELSE
        OUTPUT "No data entered."
    ENDIF
END

Identifying the data that should be stored

Before writing steps, decide what the algorithm must remember. Three questions find every stored item: what comes in (inputs), what must be carried from one step to the next (state such as totals, counters and “best so far”), and what goes out (outputs). Anything that does not need to survive to the next step can be a temporary value.

Worked example: the highest mark and the number of passes

Problem: marks are typed in one at a time until -1 is entered. Report the highest mark and how many students scored 50 or more.

BEGIN FindHighest
    highest ← 0
    passCount ← 0
    INPUT mark
    WHILE mark != -1
        IF mark > highest THEN
            highest ← mark
        ENDIF
        IF mark >= 50 THEN
            passCount ← passCount + 1
        ENDIF
        INPUT mark
    ENDWHILE
    OUTPUT "Highest: ", highest
    OUTPUT "Passes: ", passCount
END FindHighest

This one algorithm uses all three structures: sequence (initialise, loop, report), selection (two independent IF tests) and iteration (the WHILE loop). A desk check with the marks 72, 45, 91, 50 records the stored values after each pass:

The same design in Python reads the marks from a list, so it can be run and checked straight away.

marks = [72, 45, 91, 50]
highest = 0
pass_count = 0
for mark in marks:
    if mark > highest:
        highest = mark
    if mark >= 50:
        pass_count = pass_count + 1
print("Highest:", highest)
print("Passes:", pass_count)

Highest: 91
Passes: 3

Computational thinking

Computational thinking is the habit behind every design above. It has four parts, and you use all four whenever you plan an algorithm.

By combining sequence, selection, iteration and effective data storage, algorithms become clear, testable and maintainable.

Divide and Conquer, and Backtracking

🎯 (SE-11-02)

📌 Apply divide and conquer and backtracking as algorithmic design strategies

Divide and Conquer

This strategy involves breaking a complex problem into smaller, identical sub-problems until they are simple enough to solve directly. The solutions to these sub-problems are then combined to form the final result.In a Merge Sort, a large list is repeatedly split in half until single elements remain, which are then merged back together in the correct order. This approach is highly efficient for sorting and searching large datasets.

The three steps

1. Divide the problem into smaller sub-problems of the same kind.
2. Conquer each sub-problem, by solving it directly when it is small enough (the base case) or by applying the same method again.
3. Combine the sub-solutions into the answer to the original problem. Binary search needs no combining because it discards the half that cannot contain the target.

Worked example: binary search

Binary search finds a target in a sorted list by checking the middle item and discarding the half that cannot contain it. NESA-style pseudocode for the algorithm:

BEGIN BinarySearch (list, target)
    low ← 0
    high ← LENGTH(list) - 1
    WHILE low <= high
        mid ← whole number part of (low + high) / 2
        IF list[mid] = target THEN
            RETURN mid
        ELSE
            IF list[mid] < target THEN
                low ← mid + 1
            ELSE
                high ← mid - 1
            ENDIF
        ENDIF
    ENDWHILE
    RETURN -1
END BinarySearch (list, target)

Trace it with the sorted list [12, 19, 25, 31, 44, 57, 63, 78, 90] (indexes 0 to 8) and the target 57:

Three comparisons found the target. Linear search would have needed six. For a target that is absent, such as 50, the same three passes end with low greater than high and the algorithm returns -1. Step through binary search yourself in the interactive trace in the next section.

def binary_search(items, target):
    low = 0
    high = len(items) - 1
    while low <= high:
        mid = (low + high) // 2
        if items[mid] == target:
            return mid
        elif items[mid] < target:
            low = mid + 1
        else:
            high = mid - 1
    return -1

marks = [12, 19, 25, 31, 44, 57, 63, 78, 90]
print(binary_search(marks, 57))
print(binary_search(marks, 50))

5
-1

Worked example: merge sort

Merge sort divides until every list has one item (a list of one item is already sorted, so this is the base case), then combines by merging two sorted lists into one. Here the list [38, 27, 43, 3, 9, 82, 10] is divided and then combined:

def merge_sort(items):
    if len(items) <= 1:                 # base case
        return items
    middle = len(items) // 2
    left = merge_sort(items[:middle])   # divide and conquer each half
    right = merge_sort(items[middle:])
    merged = []
    i = j = 0
    while i < len(left) and j < len(right):   # combine: merge two sorted lists
        if left[i] <= right[j]:
            merged.append(left[i])
            i = i + 1
        else:
            merged.append(right[j])
            j = j + 1
    return merged + left[i:] + right[j:]

print(merge_sort([38, 27, 43, 3, 9, 82, 10]))

[3, 9, 10, 27, 38, 43, 82]

Why it is efficient

Each pass halves the range, so doubling the list adds only one more comparison. That is why binary search is described as O(log n) and linear search as O(n). The price is the requirement that the data is already sorted. Merge sort takes roughly n log n steps, far fewer than the n² of bubble sort on a large list.

Backtracking

Backtracking is an incremental approach to problem-solving that builds a solution one step at a time. If the algorithm reaches a state where the current path cannot possibly lead to a valid solution (violating a constraint), it "backtracks" to the previous step and tries a different option.A Sudoku Solver attempts a number in a cell; if it later finds a conflict, it returns to that cell and tries the next available number. This strategy is essential for pathfinding and optimisation problems.

# Divide and Conquer: Recursive Binary Search
def binary_search(arr, target, low, high):
    if low > high: return -1
    mid = (low + high) // 2
    if arr[mid] == target: return mid
    elif arr[mid] > target:
        return binary_search(arr, target, low, mid - 1)
    else:
        return binary_search(arr, target, mid + 1, high)

# Backtracking: Maze Pathfinding (tries 4 directions)
visited = set()
def find_path(x, y, maze):
    if is_exit(x, y): return True
    if is_wall(x, y) or (x, y) in visited: return False

    visited.add((x, y)) # Mark as visited
    # Try all 4 directions: right, down, left, up
    for dx, dy in [(1, 0), (0, 1), (-1, 0), (0, -1)]:
        if find_path(x + dx, y + dy, maze):
            return True

    return False # Backtrack to previous cell

Worked example: a maze, step by step

The maze below has a wrong turn built in. The search tries directions in the order right, down, left, up. Watch the call stack on the right: each recursive call adds a line, and a dead end removes lines as the function returns False and control backs up to an earlier choice.

The complete function below matches the animation. The variable path collects the squares on the winning route as each call returns True, so it is built from the exit back to the start.

MAZE = ["...#.",
        "##.#.",
        ".....",
        ".####",
        "....."]
ROWS, COLS = len(MAZE), len(MAZE[0])
visited = set()
path = []

def find_path(x, y):
    """Return True if the exit (bottom-right) can be reached from (x, y)."""
    if (x, y) == (COLS - 1, ROWS - 1):
        path.append((x, y))
        return True                                   # base case: exit found
    if not (0 <= x < COLS and 0 <= y < ROWS):
        return False                                  # off the grid
    if MAZE[y][x] == "#" or (x, y) in visited:
        return False                                  # wall, or already tried
    visited.add((x, y))
    for dx, dy in [(1, 0), (0, 1), (-1, 0), (0, -1)]: # right, down, left, up
        if find_path(x + dx, y + dy):
            path.append((x, y))
            return True
    return False                                      # dead end: backtrack

print(find_path(0, 0))
print(path[::-1])

True
[(0, 0), (1, 0), (2, 0), (2, 1), (2, 2), (1, 2), (0, 2), (0, 3), (0, 4), (1, 4), (2, 4), (3, 4), (4, 4)]

Worked example: four queens

Place four queens on a 4 × 4 board so that no two share a row, column or diagonal. Backtracking places one queen per row, and undoes the last placement as soon as a row has no safe column. The trace shows the attempts in order:

def is_safe(columns, row, col):
    """columns[r] is the column of the queen already placed in row r."""
    for r, c in enumerate(columns):
        if c == col or abs(c - col) == row - r:   # same column or same diagonal
            return False
    return True

def place_queens(columns, size):
    row = len(columns)
    if row == size:
        return True                               # every row has a queen
    for col in range(size):
        if is_safe(columns, row, col):
            columns.append(col)                   # try this square
            if place_queens(columns, size):
                return True
            columns.pop()                         # undo it: backtrack
    return False

columns = []
place_queens(columns, 4)
print([c + 1 for c in columns])
for col in columns:
    print(" ".join("Q" if c == col else "." for c in range(4)))

[2, 4, 1, 3]
. Q . .
. . . Q
Q . . .
. . Q .

Both examples share a pattern you can reuse: choose an option, check the constraint, recurse to the next choice, and undo the choice if the recursion fails.

Choosing between the two strategies

Recursive Functions

A recursive function is one that calls itself. Every recursive function must have:

• Base case: The condition that stops the recursion (no more recursive calls).
• Recursive case: Where the function calls itself with a simpler input, moving toward the base case.

# Iterative approach
def factorial_iterative(n):
    result = 1
    for i in range(1, n + 1):
        result *= i
    return result

# Recursive approach
def factorial_recursive(n):
    if n == 0 or n == 1:   # Base case
        return 1
    return n * factorial_recursive(n - 1)   # Recursive case

print(factorial_iterative(5))   # 120
print(factorial_recursive(5))   # 120

# Call stack for factorial_recursive(4):
# factorial(4) → 4 × factorial(3)
#   factorial(3) → 3 × factorial(2)
#     factorial(2) → 2 × factorial(1)
#       factorial(1) → returns 1   ← base case reached
#     factorial(2) → returns 2
#   factorial(3) → returns 6
# factorial(4) → returns 24

def fibonacci(n):
    if n <= 1:           # Base cases: fib(0)=0, fib(1)=1
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

for i in range(8):
    print(fibonacci(i), end=" ")
# Output: 0 1 1 2 3 5 8 13

Pseudocode and Flowcharts

🎯 (SE-11-02)

📌 Develop structured algorithms using pseudocode and flowcharts, including the use of subprograms

Pseudocode

Pseudocode is an informal, human-readable notation for writing algorithms — a bridge between natural language and programming code. It uses common programming keywords (IF, WHILE, FOR) mixed with English-like descriptions, making logic crystal clear without being tied to a specific programming language's syntax. This allows designers and developers to communicate algorithm logic to non-programmers, and to verify correctness before investing time in actual coding.Example:

BEGIN SearchList (list, target)
    FOR index = 0 TO LENGTH(list) - 1
        IF list[index] = target THEN
            RETURN index
        ENDIF
    NEXT index
    RETURN -1        // not found
END SearchList (list, target)

Flowcharts

Flowcharts use visual symbols to represent algorithm steps and decision points. Rectangles represent processes, diamonds represent decisions, and arrows show flow direction. This visual representation makes complex logic easy to follow, helps identify loops and branches, and allows stakeholders to validate correctness before implementation.Example: A flowchart for validating user age would show a diamond (decision point) — "Is age ≥ 18?" — with two paths: YES leads to "Show full menu" and NO leads to "Show restricted menu."

NESA pseudocode conventions

NESA’s Course Specifications set the rules for pseudocode in the exam. Learn them as a checklist:

• Keywords are written in capitals.
• Structural elements come in pairs: every BEGIN has an END, every IF has an ENDIF, every WHILE an ENDWHILE, every FOR a NEXT.
• Indentation shows which lines belong to which control structure.
• When refining a solution, a subroutine can be referred to by name, with a separate algorithm of the same name giving its detail.

process 1
process 2
process 3

IF condition THEN
    process 1
ELSE
    process 2
ENDIF

CASEWHERE expression evaluates to
    choice a: process a
    choice b: process b
    OTHERWISE: default process
END CASE

IF condition A THEN
    process 1
ELSE
    IF condition B THEN
        process 2
    ELSE
        process 3
    ENDIF
ENDIF

WHILE condition is true
    process
ENDWHILE

REPEAT
    process
UNTIL condition is true

FOR variable = start TO finish STEP increment
    statements
NEXT variable

BEGIN name (parameters)
    statements
    RETURN value    // functions only
END name (parameters)

From flowchart to pseudocode

Tracing Searching and Sorting Algorithms

A desk check follows an algorithm one step at a time, recording each variable as it changes. The traces below do the same thing: the flowchart node, the pseudocode line and the data move together. Step backwards whenever you want to ask "why did it go no there?", and watch the Comparisons counter — it is how we measure an algorithm's efficiency (Big-O).

Subprograms

A subprogram (function or procedure) is a reusable block of code that performs a specific task. Pseudocode and flowcharts must clearly show how subprograms are called, what parameters they accept, and what they return. This modular approach reduces code duplication, improves readability, and makes testing easier.A main program calls FUNCTION validatePassword(pwd) which returns TRUE or FALSE, allowing the validation logic to be reused across multiple entry points.

// ❌ Cluttered (Poor Practice)
BEGIN
    // Gathering input
    OUTPUT "Enter your score out of 100"
    INPUT score
    WHILE score < 0 OR score > 100
        OUTPUT "Invalid. Please enter a valid score: "
        INPUT score
    ENDWHILE

    // Processing logic
    IF score >= 85 THEN
        grade ← "High Distinction"
    ELSE
        IF score >= 75 THEN
            grade = "Distinction"
        ELSE
            ... (and so on) ...
        ENDIF
    ENDIF
    
    // Output
    OUTPUT "Your grade is ", grade
END

In contrast, an uncluttered mainline is completely modularized, significantly reducing complexity:

// ✅ NESA-Standard Uncluttered Mainline
BEGIN Mainline
    score ← GetValidScore ()
    grade ← CalculateGrade (score)
    DisplayResult (grade)
END Mainline

// Each subroutine is developed separately, using the same name.
// The next three algorithms give the detail.

The three subroutines named in the mainline are developed next. Each is short, does one job and is named for it. The pseudocode is on the left and the same logic in Python is on the right.

BEGIN GetValidScore ()
    OUTPUT "Enter your score out of 100: "
    INPUT score
    WHILE score < 0 OR score > 100
        OUTPUT "Invalid. Enter a valid score: "
        INPUT score
    ENDWHILE
    RETURN score
END GetValidScore ()

def get_valid_score():
    score = int(input("Enter your score out of 100: "))
    while score < 0 or score > 100:
        score = int(input("Invalid. Enter a valid score: "))
    return score

BEGIN CalculateGrade (score)
    IF score >= 85 THEN
        grade ← "High Distinction"
    ELSE
        IF score >= 75 THEN
            grade ← "Distinction"
        ELSE
            IF score >= 50 THEN
                grade ← "Pass"
            ELSE
                grade ← "Fail"
            ENDIF
        ENDIF
    ENDIF
    RETURN grade
END CalculateGrade (score)

def calculate_grade(score):
    if score >= 85:
        return "High Distinction"
    elif score >= 75:
        return "Distinction"
    elif score >= 50:
        return "Pass"
    else:
        return "Fail"

BEGIN DisplayResult (grade)
    OUTPUT "Your grade is ", grade
END DisplayResult (grade)

def display_result(grade):
    print("Your grade is", grade)

def main():
    score = get_valid_score()
    grade = calculate_grade(score)
    display_result(grade)

main()

Enter your score out of 100: 78
Your grade is Distinction

Passing data in and out

A subroutine that needs data receives it through parameters. A procedure carries out an action; a function is a subroutine that passes a single value back with RETURN. These three short examples show one parameter, several parameters, and a returned value.

BEGIN ShowGreeting (name)
    OUTPUT "Welcome, ", name, "!"
END ShowGreeting (name)

BEGIN Mainline
    ShowGreeting ("Alice")
    ShowGreeting ("Ben")
END Mainline

def show_greeting(name):
    print("Welcome, " + name + "!")

show_greeting("Alice")
show_greeting("Ben")

Welcome, Alice!
Welcome, Ben!

BEGIN Multiply (a, b, product)
    product ← a * b
END Multiply (a, b, product)

BEGIN Mainline
    FOR i = 1 TO 3
        Multiply (i, 4, answer)
        OUTPUT answer
    NEXT i
END Mainline

def multiply(a, b):
    return a * b

for i in range(1, 4):
    answer = multiply(i, 4)
    print(answer)

4
8
12

BEGIN CalculateGST (price)
    RETURN price * 0.10
END CalculateGST (price)

BEGIN Mainline
    total ← 100 + CalculateGST (100)
    OUTPUT total
END Mainline

def calculate_gst(price):
    return price * 0.10

total = 100 + calculate_gst(100)
print(total)

110.0

Modelling Tools for Top-Down and Bottom-Up Design

🎯 (SE-11-02)

📌 Use modelling tools including structure charts, abstraction and refinement diagrams to support top-down and bottom-up design

Structure Charts

Structure charts are a top-down tool used to show the hierarchy of subroutines in a system. They focus on modularity, showing which module calls another and what data (parameters) or control signals (flags) are passed between them.A structure chart for an ATM would show the 'Main' module calling 'Verify PIN' and passing back a 'Valid/Invalid' flag. This allows engineers to see high-level dependencies without getting bogged down in code logic.

Abstraction and Refinement

Abstraction involves hiding implementation details to focus on high-level goals (the 'What'). Stepwise Refinement is the process of breaking those high-level goals into smaller, more specific details (the 'How').An abstract instruction like 'Initialise System' is refined into 'Set counter to 0', 'Clear display', and 'Open file stream'. Together, they allow for manageable development of complex systems.

Top-down and bottom-up design

Top-down design starts with the whole problem and breaks it into smaller and smaller subroutines until each is simple enough to code. Bottom-up design starts with small, tested building blocks (or existing library functions) and joins them into larger parts. Most real projects use both: plan from the top, but build on reliable pieces at the bottom.

Reading a structure chart

The structure chart in the ATM figure uses four symbols from NESA’s Course Specifications. Each one answers a question about how the modules relate:

Worked example: refining the canteen program

Stepwise refinement works down through levels, adding detail only where it is needed. Each level is a complete, readable algorithm on its own. Level 0 is the mainline; level 1 refines GetOrder; level 2 refines the input check.

BEGIN Mainline
    GetOrder (items, total)
    ApplyDiscount (total, items)
    DisplayTotal (total)
END Mainline

BEGIN GetOrder (items, total)
    items ← 0
    total ← 0
    ReadWholeNumber (price)
    WHILE price != 0
        ReadWholeNumber (quantity)
        items ← items + quantity
        total ← total + price * quantity
        ReadWholeNumber (price)
    ENDWHILE
END GetOrder (items, total)

BEGIN ReadWholeNumber (number)
    REPEAT
        INPUT text
    UNTIL text is a whole number of 0 or more
    number ← text as a number
END ReadWholeNumber (number)

The same hierarchy is what the structure chart shows: Mainline at the top calling GetOrder, ApplyDiscount and DisplayTotal, with GetOrder calling ReadWholeNumber repeatedly (a curved arrow), and items and total passed back up as data (empty circles). A refinement level can be drawn as its own structure chart with the same name as the box it refines.

Analysing the Logic of Written Algorithms

🎯 (SE-11-02)

📌 Analyse the logic and structure of written algorithms

• determining inputs and outputs
• determining the purpose of the algorithm
• desk checking and peer checking
• determining connections of written algorithms to other subroutines or functions

Determining Inputs, Outputs, and Purpose

Before writing code, clearly identify what data the algorithm needs (inputs), what it produces (outputs), and why it exists (purpose). This clarity prevents bugs and ensures the solution addresses the right problem.A sorting algorithm has INPUT: unsorted list; OUTPUT: sorted list; PURPOSE: arrange items in ascending order for efficient searching.

Desk Checking and Peer Checking

Desk checking (or "dry running") involves manually tracing through an algorithm step-by-step with sample data, recording the value of each variable at each step to verify correctness before implementation. Peer checking is having another person review the algorithm logic to catch errors or inefficiencies that the original author might miss.Desk checking a loop from 1 to 10 — write down i=1, i=2, ... to verify the loop executes exactly 10 times, not 9 or 11.

Identifying Connections to Subroutines and Functions

Analyse how an algorithm calls other functions and what data is passed between them. Document the purpose of each function call and the parameters it receives, ensuring data flows correctly through the program.An algorithm that calculates employee pay might call FUNCTION calculateTax(salary) and FUNCTION applyBonus(basePay, bonusPercent), understanding what each returns and how it affects the final result.

BEGIN Mystery (list)
    result ← list[0]
    FOR i = 1 TO LEN(list) - 1
        IF list[i] > result THEN
            result ← list[i]
        ENDIF
    NEXT i
    RETURN result
END Mystery (list)

Clues that reveal purpose

Worked desk check: finding a logic error

An algorithm should count the marks of 50 or more in a list. It compiles and runs, so a desk check with chosen data is how the fault is found. The array positions run from 1 in this algorithm.

BEGIN CountPasses (marks)
    count ← 0
    FOR i = 1 TO LENGTH(marks)
        IF marks[i] > 50 THEN
            count ← count + 1
        ENDIF
    NEXT i
    RETURN count
END CountPasses (marks)

Test data: marks = [45, 60, 50]. Expected result: 2 (60 and 50 are passes). Record each variable after every pass of the loop:

The desk check returns 1, not 2. The mismatch appears at i = 3: a mark of exactly 50 is rejected because the test uses > instead of >=. This is a boundary fault, and it is the reason boundary values are always part of the test data. Choosing 50 as one of the desk-check values is what exposed it.

Peer checking

A peer checker reads the algorithm without the author’s assumptions. Give them a short checklist so the review is systematic:

• Can they state the purpose, inputs and outputs from the algorithm alone?
• Does every variable start with a sensible value before it is used?
• Does each loop change something that eventually ends it?
• Are boundary values (first, last, empty, exactly on a limit) handled?
• Do names, indentation and matching pairs (IF/ENDIF, WHILE/ENDWHILE) make the structure clear?

Following the data through subroutine calls

Connections between algorithms are where data is often lost or mixed up. Draw up a small table of every call: what is passed in, what the parameter is called, and what comes back. Here is the pay example from above.

BEGIN PayEmployee (salary, bonusPercent)
    tax ← CalculateTax (salary)
    pay ← salary - tax + ApplyBonus (salary, bonusPercent)
    RETURN pay
END PayEmployee (salary, bonusPercent)

The parameter names inside a subroutine need not match the caller’s names, but the order, number and type of the arguments must. Passing bonusPercent first and salary second would run without a crash and give a wrong answer.

Identifying Procedures and Functions

🎯 (SE-11-02)

📌 Identify procedures and functions in an algorithm

A subprogram is a named block of steps that can be called from elsewhere in an algorithm. There are two kinds, and spotting which is which tells you how the algorithm fits together.

Functions vs Procedures

Return Values

# Single return value
def circle_area(radius):
    import math
    return math.pi * radius ** 2

# Multiple return values (Python returns a tuple)
def min_max(numbers):
    return min(numbers), max(numbers)

low, high = min_max([5, 3, 9, 1, 7])
print(low, high)   # 1  9

# Function returning None (procedure style)
def greet(name):
    print(f"Hello, {name}!")
    # no return statement → returns None implicitly

Parameters and arguments

A parameter is the name a subprogram gives to a piece of data it expects. An argument is the actual value supplied when it is called. In calculate_gst(price), price is the parameter; in calculate_gst(80), 80 is the argument. NESA treats subroutine, module, subprogram and procedure as interchangeable words for a named group of statements; a function is the kind that returns a single value.

Worked example: identify each subprogram

Read this algorithm and decide, for each named subprogram, whether it is a procedure or a function.

BEGIN ProcessOrder (items, total)
    ShowWelcome ()
    gst ← CalculateGST (total)
    final ← total + gst
    IF items >= 10 THEN
        final ← final - Discount (final)
    ENDIF
    PrintReceipt (items, final)
END ProcessOrder (items, total)

Common mistakes with return values

A function’s value is lost unless the caller does something with it. Two errors appear again and again in student code:

def calculate_gst(price):
    return price * 0.10

calculate_gst(80)               # mistake: the returned 8.0 is thrown away
print(calculate_gst(80))        # 8.0: the value is used

def show_total(total):
    print("Total:", total)      # a procedure: prints, returns None

result = show_total(90)
print(result)                   # None: there is nothing useful to store

8.0
Total: 90
None

RETURN also ends the subprogram immediately. Any statement written after it in the same path never runs, which is why linear search returns from inside the loop as soon as it finds a match.

Programming Paradigms

🎯 (SE-11-02)

📌 Experiment with object-oriented programming, imperative, logic and functional programming paradigms

Object-Oriented Programming (OOP)

Data and functions are bundled together in "objects" that model real-world entities. Emphasises reusability, modularity, and maintainability. Classes define blueprints; instances are created from them.A Car class has properties (colour, speed) and methods (accelerate(), brake()); multiple car objects can be created from this template.

Imperative Programming

Programs are sequences of explicit commands (statements) that change program state step-by-step. Python, Java, and C are imperative languages. Focus on "how" to solve the problem (procedures and control flow)."Set count to 0; LOOP: add next number to count; increment loop counter; IF loop counter < 10, GO TO LOOP."

Logic Programming

Programs state facts and rules; the interpreter derives new facts through logical inference. Less common than imperative, but heavily used in artificial intelligence, constraint logic, and database query planning. Focus on "what" is true, not "how" to compute it.

% NESA requires students to "define and edit facts" and "create, edit and remove rules"

% 1. DEFINE FACTS (The fundamental truths of the knowledge base)
parent(john, mary).
parent(john, peter).
parent(mary, bob).
parent(peter, sarah).

% 2. CREATE RULES (Logic derived from facts using variables)
% "X is a grandparent of Z IF X is a parent of Y AND Y is a parent of Z"
grandparent(X, Z) :- 
    parent(X, Y), 
    parent(Y, Z).

% "A and B are siblings IF they share a parent P AND are not the same person"
sibling(A, B) :- 
    parent(P, A), 
    parent(P, B),
    A \= B. 

% 3. LOGIC ENGINE INFERENCE (Querying the system)
% This is how a logic paradigm dynamically solves problems without imperative loops:

% Query: grandparent(john, bob).
% Engine derivation steps:
% - Search: parent(john, Y) -> Matches Y = mary
% - Search: parent(mary, bob) -> Fact exists!
% Output: TRUE

% Query: sibling(mary, peter).
% Engine derivation steps:
% - Search: parent(P, mary) -> Matches P = john
% - Search: parent(john, peter) -> Fact exists!
% - Search: mary \= peter -> TRUE
% Output: TRUE

λ Functional Programming

Programs are built from pure functions (same input always produces same output, no side effects) and immutable data. Emphasises recursion and function composition.Example (Lisp/Scheme): Computing factorial recursively as (factorial 5) = 5 × (factorial 4), where (factorial 4) = 4 × (factorial 3), and so on down to (factorial 1) = 1, without modifying any variable.

Modern development often uses hybrid approaches — Python supports both OOP and functional styles; JavaScript supports imperative and functional paradigms. Experimenting with different paradigms strengthens problem-solving skills and helps you choose the best tool for each context.

Experiment: one problem, four ways

The syllabus asks you to experiment with the paradigms, and the best way is to solve one problem in each and compare. The problem: a canteen order has three items priced 10.00, 25.50 and 4.50 dollars. Add 10% GST to each and report the total.

Imperative: a sequence of steps that change state

prices = [10.00, 25.50, 4.50]
total = 0
for price in prices:
    total = total + price * 1.10     # total is changed on every pass
print(round(total, 2))

44.0

Functional: expressions with no changing variables

prices = [10.00, 25.50, 4.50]
add_gst = lambda price: price * 1.10        # a pure function
print(round(sum(add_gst(p) for p in prices), 2))

44.0

Object-oriented: data and behaviour bundled in a class

class Cart:
    def __init__(self):
        self.prices = []

    def add(self, price):
        self.prices.append(price)

    def total_with_gst(self):
        return round(sum(self.prices) * 1.10, 2)

cart = Cart()
for price in [10.00, 25.50, 4.50]:
    cart.add(price)
print(cart.total_with_gst())

44.0

Logic: facts and rules, then a query

Prolog has no loop. You state facts and a rule, then ask a question and the engine works out the answer. Here the rule says a price with GST is the price times 11, divided by 10.

price(pen, 10.00).
price(book, 25.50).
price(bag, 4.50).

with_gst(Item, Total) :- price(Item, P), Total is P * 11 / 10.

% Query:  ?- with_gst(book, T).
% Answer: T = 28.05

The first three give the same 44.0. The Prolog query asks about one item (25.50 with GST is 28.05) because a logic program answers questions rather than running steps. What differs between the paradigms is how you think about the problem.

Try this: add a fourth price with the imperative version, then with each of the others. Which was easiest to change? Which is easiest to test on its own? Write two sentences on which paradigm you would choose for a rule-based timetable checker and why.

Number Systems

🎯 (SE-11-03)

📌 Investigate the use of number systems for computing purposes, including binary, decimal and hexadecimal

Computers store everything as binary, but people read and write numbers in other bases. Software engineers move between three of them.

• Binary (Base 2): Used by hardware for electrical on/off states.
• Decimal (Base 10): The standard human system for counting.
• Hexadecimal (Base 16): Efficiently represents bytes (e.g., #FFFFFF for white in CSS).

Converting between bases

• Binary → decimal: add the place values that hold a 1. For 1011: 8 + 0 + 2 + 1 = 11.
• Decimal → binary: divide by 2 repeatedly and read the remainders from bottom to top.
• Binary ↔ hexadecimal: split the binary into groups of four bits. 1010 1111 → A F → AF.

Place value in three bases

Every base works the same way: each digit is worth the digit times a place value, and each place is the base times bigger than the one on its right. Decimal places are powers of 10, binary places are powers of 2 and hexadecimal places are powers of 16.

Hexadecimal needs sixteen digits, so the letters A to F stand for the values 10 to 15:

Worked conversions

Decimal to binary: repeated division by 2

Convert 156. Divide by 2, record the remainder, and repeat with the quotient until it reaches 0.

Read the remainders from the bottom up: 10011100. Check by adding place values: 128 + 16 + 8 + 4 = 156.

Binary to hexadecimal, and back

Split the binary number into groups of four from the right, then convert each group with the table above: 1001 1100 is 9 and C, so 156 is 9C in hexadecimal. To go back, replace each hex digit with its four bits.

Hexadecimal to decimal

Multiply each digit by its place value and add: 9C = 9 × 16 + 12 × 1 = 144 + 12 = 156. This matches the other two forms.

Decimal to hexadecimal directly

Divide by 16 instead of 2: 156 ÷ 16 = 9 remainder 12, and 12 is C. Reading the remainders from the bottom gives 9C.

Checking conversions in Python

number = 156
print(bin(number))              # 0b10011100
print(hex(number))              # 0x9c
print(f"{number:08b}")          # 10011100  (8 bits, padded with zeros)
print(f"{number:X}")            # 9C
print(int("10011100", 2))       # 156
print(int("9C", 16))            # 156

0b10011100
0x9c
10011100
9C
156
156

Where each base is used

• Binary is how hardware stores everything. A bit is one binary digit; a byte is eight bits and can hold 2⁸ = 256 different values (0 to 255).
• Hexadecimal shortens binary for people: colour codes such as #FF8800 (red FF = 255, green 88 = 136, blue 00 = 0), memory addresses and MAC addresses.
• Decimal is for people: prices, marks and counts.

Two's Complement

🎯 (SE-11-03)

📌 Represent integers using two’s complement

Two's Complement is the standard method for representing signed (negative) integers in binary. To represent a negative number, the bits of the positive equivalent are inverted (0 to 1 and vice-versa) and 1 is added to the result. This system is preferred as it allows for simple addition/subtraction circuits and eliminates the 'double zero' (+0 and -0) problem used in older systems.

1. Start with the positive number: 5 = 00000101
2. Invert all bits (One's Complement): 11111010 (each 0 becomes 1, each 1 becomes 0)
3. Add 1 to the result: 11111010 + 1 = 11111011
4. Result: -5 in 8-bit Two's Complement = 11111011

Verification: If we add 5 and -5 in binary: 00000101 + 11111011 = 100000000 (the overflow bit carries out, leaving 00000000 = 0 ✓)

# Representing integers in different bases
number = 255
print(bin(number)) # 0b11111111 (Binary)
print(hex(number)) # 0xff       (Hexadecimal)

# Binary to Decimal for hardware addresses
print(int("1010", 2)) # 10

Why two’s complement?

A computer needs a way to store negative whole numbers using only 0s and 1s. The simplest idea is to use the left-hand bit as a sign, but that gives two zeros (+0 and −0) and makes subtraction awkward. In two’s complement there is one zero, and the same adding circuit handles positive and negative numbers.

Range of an n-bit number

The left-hand bit is the sign bit: 0 for zero and positive numbers, 1 for negative numbers. With n bits the range is −2ⁿ⁻¹ to 2ⁿ⁻¹ − 1. There is one more negative value than positive.

More worked examples (8 bits)

Reading a negative pattern

To find the value of 11110110: the sign bit is 1, so it is negative. Invert the bits (00001001), add 1 (00001010 = 10) and put a minus sign in front: −10. You can check with signed place values: the sign bit is worth −128, so −128 + 64 + 32 + 16 + 4 + 2 = −10.

Subtraction becomes addition

To calculate 7 − 5, add 7 and −5: 00000111 + 11111011 = 1 00000010. The carry out of the eighth bit is discarded, leaving 00000010, which is 2.

Overflow

If a result does not fit in the available bits, it wraps round. In 8 bits, 01111111 (127) plus 1 is 10000000, which is −128. This is overflow, and it is why the Year 2038 problem in the section introduction matters: a 32-bit signed count of seconds runs out of positive values in January 2038.

print(f"{-5 & 0xFF:08b}")           # 11111011   -5 as 8 bits
print(int("11111011", 2) - 256)     # -5         read 8 bits back as signed
print(f"{-20 & 0xFF:08b}")          # 11101100
print(int("11110110", 2) - 256)     # -10

11111011
-5
11101100
-10

In Python, & 0xFF keeps only the lowest eight bits, which is what an 8-bit store would keep. Subtracting 256 (2⁸) from a pattern whose sign bit is 1 gives its signed value.

Explore it: number base and two’s complement workbench

Use the workbench to check your own conversions. Type a number in any base, or click the bits, and it shows the working. Try −5, then 127 with the Add 1 button to see overflow, then open the self-check at the bottom.

Standard Data Types

🎯 (SE-11-03, SE-11-04)

📌 Investigate standard data types

• char (character) and string
• Boolean
• real
• single precision floating point
• integer
• date and time

A data type tells the computer what kind of value a variable holds, how much memory to set aside, and which operations make sense. Choosing the right type prevents errors and saves memory.

Choosing a data type

• Use an integer for things you count (students, clicks). Use a real for things you measure (temperature, price).
• A single precision floating point number uses 32 bits and keeps about 7 significant digits, so it can round large or very precise values. That's why money is often stored as whole cents.
• Store phone numbers and postcodes as strings. You never do arithmetic on them, and a leading zero would disappear from an integer.
• Store dates with a date/time type rather than text, so you can sort them and calculate differences.

The six standard types in detail

char (character) and string

A char holds one character: a letter, digit, space or symbol. Internally it is stored as a number, its code in ASCII or Unicode. A string is a sequence of characters. Python has no separate char type; a char is a string of length 1.

print(ord("A"))            # 65    the code for A
print(chr(97))             # a     the character with code 97
word = "HSC"
print(word[0], word[1:], len(word))   # H SC 3

65
a
H SC 3

Boolean

A Boolean holds one of two values, True or False. Every comparison produces one, and every IF and WHILE test relies on one. It needs only a single bit of storage. Name Boolean variables as questions: is_valid, has_discount.

mark = 50
passed = mark >= 50
print(passed, type(passed).__name__)    # True bool

True bool

integer

An integer is a whole number with no fractional part, positive or negative, stored in binary (two’s complement for negatives). Use it for anything you count. In many languages an integer has a fixed size; a 16-bit signed integer holds −32 768 to 32 767 and a 32-bit one about ±2 billion. Python integers grow as needed, so overflow is a concern in other languages and in hardware.

real

A real number has a fractional part, such as a measurement or a rate. It is stored in floating point form, which stores most values only approximately. That leads to a classic surprise:

print(0.1 + 0.2)                        # 0.30000000000000004
print(0.1 + 0.2 == 0.3)                 # False
print(abs((0.1 + 0.2) - 0.3) < 1e-9)    # True: compare with a small tolerance
print(round(0.1 + 0.2, 2))              # 0.3

0.30000000000000004
False
True
0.3

Never test two real numbers for exact equality. Compare them within a small tolerance, or store money as whole cents.

single precision floating point

Single precision uses 32 bits (4 bytes) for a real number: 1 sign bit, 8 bits for the exponent (the scale) and 23 bits for the fraction (the digits). That gives about 7 significant decimal digits. Values beyond that precision are rounded, as the next example shows.

import struct

def as_single(value):
    """Store value as a 32-bit float and read it back."""
    return struct.unpack("f", struct.pack("f", value))[0]

print(as_single(0.1))         # 0.10000000149011612
print(as_single(16777217))    # 16777216.0

0.10000000149011612
16777216.0

The first line shows that 0.1 cannot be stored exactly. The second shows that after 16 777 216 (2²⁴) single precision can no longer represent every whole number, so 16 777 217 is stored as 16 777 216. Double precision (64 bits) is the default real type in Python and gives about 15 to 16 digits.

date and time

A date and time type stores a moment as one number, so dates can be sorted and subtracted. NESA specifies that it is always stored as 32 bits (4 bytes) and displayed in whatever format the program chooses, such as DD/MM/YYYY. A 32-bit count of seconds from 1 January 1970 runs out in January 2038, which is the Year 2038 problem.

from datetime import date

enrolled = date(2026, 3, 14)
print(enrolled.strftime("%d/%m/%Y"))    # 14/03/2026
deadline = date(2026, 10, 12)
print((deadline - enrolled).days)           # 212  days between the two dates

14/03/2026
212

Storing a date as text such as "14/03/2026" would sort in the wrong order and make date arithmetic hard, which is why a real date type is used.

Data Dictionaries

🎯 (SE-11-03, SE-11-04)

📌 Create data dictionaries as a tool to describe data and data types, structure data, and record relationships

A data dictionary is a table that gives a comprehensive description of each variable stored or referred to in a system, before any code is written. NESA’s Course Specifications list what it commonly includes: the variable name, data type, format for display, size in bytes, size for display, the purpose of the variable, a relevant example and any validation rules. Everyone on the team then works from the same definitions.

Recording relationships

When data is split across tables, the dictionary also records how they link. For example, Enrolment.StudentId must match an existing Student.StudentId, so every enrolment belongs to a real student. The primary key (Student.StudentId) uniquely identifies each row; the matching column in the other table is a foreign key. One student can have many enrolments, so this is a one-to-many relationship. Note the key and the link in the Description or Validation column.

Describing data and data types

Each column answers a different question a programmer will ask when writing or testing code:

Structuring data

A data dictionary also records how variables are grouped. The variables above form one record: a student. Several students form an array of records. The dictionary can list the record once, then note that the system stores an array of them. In Python:

students = [
    {"StudentId": 10482, "FirstName": "Priya", "YearLevel": 11},
    {"StudentId": 10517, "FirstName": "Marcus", "YearLevel": 12},
]
for student in students:
    print(student["StudentId"], student["FirstName"])

10482 Priya
10517 Marcus

Turning validation rules into code

Every validation entry in the dictionary should become a check in the program, and a test case. Here are two rules from the table:

def valid_year_level(value):
    """YearLevel: integer, must be 11 or 12."""
    return isinstance(value, int) and value in (11, 12)

def valid_student_id(value, existing_ids):
    """StudentId: whole number 10000 to 99999, unique."""
    return isinstance(value, int) and 10000 <= value <= 99999 and value not in existing_ids

print(valid_year_level(11), valid_year_level(10), valid_year_level("11"))
print(valid_student_id(10482, [10517]), valid_student_id(10517, [10517]), valid_student_id(9999, []))

True False False
True False False

Worked example: creating a data dictionary

Follow these steps for any system. For the canteen order calculator: (1) list every value the algorithm needs from the requirements; (2) name each in one style; (3) choose a data type; (4) decide the display format and sizes; (5) write a description and a realistic example; (6) add a validation rule you can test.

Arrays, Records, Trees and Sequential Files

🎯 (SE-11-03, SE-11-04)

📌 Use data structures of arrays, records, trees and sequential files

# Single dimension
scores = [45, 67, 89]
# Multidimensional
board = [[0 for _ in range(8)] for _ in range(8)]

# In Python, using a class or dictionary
student = {
    "name": "Alice",
    "id": 12345,
    "gpa": 3.95
}

history = []; history.append("Action"); history.pop()

users = {"alice": {"age": 17, "year": 11}}

Using each structure: worked examples

Arrays

An array is read by position. Positions start at 0. A two-dimensional array needs a row and a column. (Python lists are more flexible than the fixed-size arrays of other languages, but are used the same way.)

scores = [45, 67, 89]
print(scores[0], scores[2], len(scores))     # first, last, how many

board = [[1, 2, 3],
         [4, 5, 6],
         [7, 8, 9]]
print(board[1][2])                           # row 1, column 2
for row in board:
    print(row)

45 89 3
6
[1, 2, 3]
[4, 5, 6]
[7, 8, 9]

Records

A record groups fields of different types about one thing. A collection of records is a list of them.

student = {"name": "Alice", "id": 12345, "gpa": 3.95}
print(student["name"], student["id"])
student["gpa"] = 4.0
print(student)

Alice 12345
{'name': 'Alice', 'id': 12345, 'gpa': 4.0}

Trees

A tree is naturally processed by a function that handles one node, then calls itself on each child. This prints a folder hierarchy with indentation for depth:

folders = {"Documents": {"Reports": {}, "Photos": {"2026": {}}}, "Music": {}}

def show(tree, depth=0):
    for name, children in tree.items():
        print("    " * depth + name)
        show(children, depth + 1)

show(folders)

Documents
    Reports
    Photos
        2026
Music

Sequential files

A sequential file is written and read from the start, one record at a time. To find one record you scan from the top until you reach it.

with open("scores.txt", "w") as file:          # write mode replaces the file
    for name, mark in [("Ava", 72), ("Ben", 85), ("Cai", 64)]:
        file.write(f"{name},{mark}\n")

with open("scores.txt") as file:               # read it back in order
    for line in file:
        name, mark = line.strip().split(",")
        print(name, mark)

Ava 72
Ben 85
Cai 64

The file scores.txt now holds three lines, Ava,72, Ben,85 and Cai,64. Using with closes the file automatically, even if an error occurs.

Stacks and hash tables

A stack only lets you add and remove at the top. A hash table uses a hash function to turn a key into a slot number, so it can jump straight to a value. Two keys can land in the same slot; that is a collision, and the table needs a plan for it (implemented in the next part). A toy hash function that adds the character codes and takes the remainder after dividing by 7 shows this:

def toy_hash(key, size=7):
    return sum(ord(ch) for ch in key) % size

for key in ["Ava", "Ben", "Cai", "Dev"]:
    print(key, "goes to slot", toy_hash(key))

Ava goes to slot 0
Ben goes to slot 4
Cai goes to slot 3
Dev goes to slot 0

“Ava” and “Dev” collide in slot 0.

Choosing a structure

Developing a Software Solution

🎯 (SE-11-06)

📌 Apply skills in computational thinking and programming to develop a software solution

• converting an algorithm into code
• using control structures
• using data structures
• using standard modules
• creating relevant subprograms that incorporate parameter passing

Converting Algorithm to Code

Translating pseudocode or flowcharts into actual programming language syntax. Each algorithm step becomes a statement; pseudocode's IF becomes the language's if keyword; loops translate directly.

Using Control Structures

Implementing sequence (statements in order), selection (if/else, switch), and iteration (for, while loops) to direct program flow based on conditions and data.

Using Data Structures

Selecting and implementing appropriate data structures (arrays, records, trees, hash tables) to organise data so algorithms can access it efficiently.

Using Standard Modules

Leveraging built-in libraries and functions (e.g., Python's math module, datetime module, string methods) instead of reinventing functionality. Standard modules are tested, optimised, and consistent across projects.

Creating Subprograms with Parameter Passing

Writing functions and procedures that accept parameters (inputs), perform a specific task, and return results. Parameters can be passed by value (copy) or by reference (address), allowing functions to modify caller's data when needed.FUNCTION calculateBonus(salary, percent) takes two parameters, calculates the bonus, and returns the result.

Parameter Passing

Pass by value: A copy of the variable is sent. The original variable in the caller is unchanged, even if the function modifies the parameter.

def double(n):
    n = n * 2     # modifies the local copy only
    return n

score = 50
result = double(score)
print(score)    # still 50 — original unchanged
print(result)   # 100

Pass by reference (mutable objects): Python passes a reference to the object. Mutable types (lists, dicts) can be modified inside the function — the caller sees the change.

def add_score(scores, new_score):
    scores.append(new_score)   # modifies the original list

results = [80, 75, 90]
add_score(results, 95)
print(results)   # [80, 75, 90, 95] — list WAS modified

Variable Scope

Scope determines which parts of your program can access a variable. Python uses the LEGB rule to look up names:

LEGB Lookup Order
─────────────────────────────────────────────
L  Local      — variables defined inside the current function
E  Enclosing  — variables in any enclosing (outer) function
G  Global     — variables defined at module level
B  Built-in   — Python's built-in names (print, len, range…)
─────────────────────────────────────────────
Python searches L → E → G → B until the name is found.

x = 10           # Global scope

def show():
    x = 99       # Local scope — shadows the global x
    print(x)     # 99

show()
print(x)         # 10 — global unchanged

# Using global keyword (avoid when possible)
counter = 0
def increment():
    global counter
    counter += 1

increment()
print(counter)   # 1

Worked example: converting NESA pseudocode to Python

Converting is a line-by-line translation, once you know the equivalent of each NESA structure in Python.

menu_choice = 2
match menu_choice:                  # CASEWHERE menuChoice evaluates to
    case 1:
        print("New game")
    case 2:
        print("Load game")
    case 3:
        print("High scores")
    case _:                         # OTHERWISE
        print("Invalid choice")

Load game

Worked example: a marks report using all five skills

This short program converts an algorithm into code and uses control structures, a data structure (a list), a standard module (statistics) and subprograms with parameters. The algorithm is written first.

BEGIN MarksReport
    marks ← [72, 85, 64, 90, 58]
    OUTPUT "Average: ", Average (marks)
    OUTPUT "Highest: ", Highest (marks)
    OUTPUT "Grade of highest: ", GradeFor (Highest (marks))
END MarksReport

BEGIN GradeFor (mark)
    IF mark >= 85 THEN
        RETURN "High Distinction"
    ELSE
        IF mark >= 75 THEN
            RETURN "Distinction"
        ELSE
            IF mark >= 50 THEN
                RETURN "Pass"
            ELSE
                RETURN "Fail"
            ENDIF
        ENDIF
    ENDIF
END GradeFor (mark)

import statistics                   # standard module: tested code we do not have to write

def average(marks):
    return statistics.mean(marks)

def highest(marks):
    best = marks[0]
    for mark in marks:              # iteration over a list (data structure)
        if mark > best:             # selection
            best = mark
    return best

def grade_for(mark):
    if mark >= 85:
        return "High Distinction"
    elif mark >= 75:
        return "Distinction"
    elif mark >= 50:
        return "Pass"
    else:
        return "Fail"

marks = [72, 85, 64, 90, 58]
print("Average:", round(average(marks), 1))
print("Highest:", highest(marks))
print("Grade of highest:", grade_for(highest(marks)))

Average: 73.8
Highest: 90
Grade of highest: High Distinction

Standard modules save time and are already tested. Three you will use often: math (for example math.sqrt(144) gives 12.0), statistics (mean, median) and datetime (dates and times). Import a module once at the top, then call its functions.

def reset_scores(scores):
    scores = []            # re-points the local name only

def clear_scores(scores):
    scores.clear()         # changes the caller's list in place

results = [80, 75, 90]
reset_scores(results)
print(results)             # [80, 75, 90]  unchanged
clear_scores(results)
print(results)             # []            changed

[80, 75, 90]
[]

Implementing Data Structures for Storage

🎯 (SE-11-02, SE-11-04)

📌 Implement data structures that support data storage

• single and multidimensional arrays
• lists
• trees
• stacks
• hash tables

Once you know which data your program needs, choose a structure that stores it well. Each structure below is built into Python or easy to make from a list or dictionary.

history = []                 # the stack

def do(action):
    history.append(action)   # push

def undo():
    if history:
        return history.pop()  # pop: last action comes off first

do("type A"); do("type B")
print(undo())                # type B

Single and multidimensional arrays

Create a grid with a loop, not by repeating a row: [["free"] * 4] * 3 makes three references to the same row, so changing one seat changes them all.

plan = [["free"] * 4 for _ in range(3)]    # 3 rows, 4 seats, each row separate
plan[1][2] = "Ava"                          # row 1, seat 2
for row in plan:
    print(row)

['free', 'free', 'free', 'free']
['free', 'free', 'Ava', 'free']
['free', 'free', 'free', 'free']

Lists

A list grows and shrinks, which makes it the usual choice when the number of items is not known in advance.

queue = ["Priya", "Ben"]
queue.append("Cai")        # add to the end
queue.insert(0, "Ava")     # add at the front
queue.remove("Ben")        # remove by value
print(queue, len(queue))
queue.sort()
print(queue)

['Ava', 'Priya', 'Cai'] 3
['Ava', 'Cai', 'Priya']

Trees

A binary search tree keeps smaller values to the left and larger to the right, so an in-order walk visits values in sorted order.

class Node:
    def __init__(self, value):
        self.value = value
        self.left = None
        self.right = None

def insert(node, value):
    if node is None:
        return Node(value)                     # base case: an empty spot
    if value < node.value:
        node.left = insert(node.left, value)
    else:
        node.right = insert(node.right, value)
    return node

def in_order(node):
    if node is not None:
        in_order(node.left)
        print(node.value, end=" ")
        in_order(node.right)

root = None
for name in ["Kim", "Ben", "Zoe", "Ava", "Leo"]:
    root = insert(root, name)
in_order(root)

Ava Ben Kim Leo Zoe

Stacks

The undo example above pushes and pops. Stacks also check that brackets match: push each opening bracket and pop when a closing one appears.

def balanced(text):
    stack = []
    pairs = {")": "(", "]": "["}
    for ch in text:
        if ch in "([":
            stack.append(ch)                              # push
        elif ch in ")]":
            if not stack or stack.pop() != pairs[ch]:     # pop and compare
                return False
    return not stack                                      # nothing left open

print(balanced("(a[1] + 2)"), balanced("(a[1)]"))

True False

Hash tables

Python’s dict is a hash table. Building a small one shows what happens inside: a hash function picks a slot, and each slot holds a short list so that colliding keys can share it.

class HashTable:
    def __init__(self, size=7):
        self.slots = [[] for _ in range(size)]

    def _index(self, key):
        return sum(ord(c) for c in key) % len(self.slots)

    def put(self, key, value):
        bucket = self.slots[self._index(key)]
        for pair in bucket:
            if pair[0] == key:             # key already stored: replace
                pair[1] = value
                return
        bucket.append([key, value])

    def get(self, key):
        for k, v in self.slots[self._index(key)]:
            if k == key:
                return v
        return None

table = HashTable()
table.put("Ava", 72)
table.put("Dev", 55)                        # collides with Ava in slot 0
table.put("Ben", 85)
print(table.get("Dev"), table.get("Ava"), table.get("Zed"))
print(table.slots[0])

55 72 None
[['Ava', 72], ['Dev', 55]]

Waterfall and Agile

🎯 (SE-11-02)

📌 Compare the execution of the Waterfall and Agile project management models as applied to software development

Waterfall and Agile both take software from an idea to a finished product, but they run the project very differently. Waterfall completes each stage once, in order. Agile repeats short cycles and delivers working software along the way.

How each model runs

Waterfall runs the development steps as a sequence of phases, each finished and signed off before the next begins: requirements, design, development, testing, installation, maintenance. It relies on getting the requirements right at the start, because going back is costly. Agile repeats the steps in short cycles. In a common form, work is taken from a prioritised backlog into a fixed-length sprint (often one to four weeks), the team meets briefly each day, and at the end shows working software to the client, reviews what happened and plans the next sprint. The Agile Manifesto values working software, customer collaboration and responding to change over comprehensive documentation, contracts and following a plan, though it still values the items on the right.

The canteen program under each model

Choosing between them

• Waterfall suits projects with fixed, well-understood requirements and heavy documentation or approval needs, such as safety-critical control software or a system that must meet a legal specification.
• Agile suits projects where requirements will change or be discovered as the team learns, and where a client can be involved often, such as a new app.
• Many teams mix them: fixed planning up front and iterative delivery inside it. You meet this hybrid, called WAgile, in Year 12.

Testing and Evaluating Solutions

🎯 (SE-11-06, SE-11-07)

📌 Test and evaluate solutions, considering key aspects including functionality, performance, readability of code, quality of documentation

Testing asks "does it work?" Evaluating asks "is it good?" A solution can pass every test and still be slow, hard to read or poorly documented, so judge it against all four criteria.

Evaluation Criteria

Software solutions are evaluated on multiple dimensions:

• Functionality: Does the program produce correct outputs for all inputs?
• Performance: Does it run efficiently (time complexity, memory usage)?
• Readability: Is the code clear, well-structured, and easy to understand?
• Documentation Quality: Are functions documented? Are complex sections explained?

Python Naming Conventions

Descriptive Naming — Good vs Bad

Applying the four criteria

To evaluate a solution, look for evidence against each criterion. The two functions below do the same job. Judge them.

def f(a, b):
    return a * b * 0.1

GST_RATE = 0.10

def gst_amount(price, quantity):
    """Return the GST in dollars for one line item."""
    return price * quantity * GST_RATE

Both are equally correct and fast, but B is far easier to check, change and hand over. That is what evaluating adds beyond testing.

Testing methods you should know

NESA’s Course Specifications list six methods for testing a software solution:

Evaluating performance without a stopwatch

Counting the steps an algorithm takes is a fair way to compare designs, because it does not depend on the computer. Count comparisons for linear and binary search on a sorted list of 1000 numbers, looking for the last one:

def linear_comparisons(items, target):
    count = 0
    for item in items:
        count += 1
        if item == target:
            break
    return count

def binary_comparisons(items, target):
    low, high, count = 0, len(items) - 1, 0
    while low <= high:
        mid = (low + high) // 2
        count += 1
        if items[mid] == target:
            break
        elif items[mid] < target:
            low = mid + 1
        else:
            high = mid - 1
    return count

data = list(range(1, 1001))
print(linear_comparisons(data, 1000), binary_comparisons(data, 1000))

1000 10

Documentation that helps

Good documentation answers questions the code cannot. A short docstring states what a function does and what it expects. Comments explain why, not what: # cents, to avoid rounding errors is useful; # add 1 to i is noise. A README tells a new user how to install and run the program. Documentation is judged on being accurate, current and useful to its reader.

Automated tests

A test function with assert statements re-checks every case each time the code changes. An assert that is false stops the program with an AssertionError.

DISCOUNT_ITEMS = 10

def apply_discount(total, items):
    if items >= DISCOUNT_ITEMS:
        return total - total * 10 // 100
    return total

def test_apply_discount():
    assert apply_discount(4500, 9) == 4500     # just below the boundary
    assert apply_discount(4500, 10) == 4050    # on the boundary
    assert apply_discount(0, 0) == 0           # empty order

test_apply_discount()
print("All tests passed")

All tests passed

Debugging Tools

🎯 (SE-11-06, SE-11-07)

📌 Use debugging tools

• breakpoints
• single line stepping
• watches
• interfaces between functions
• debugging output statements
• debugging software available in an integrated development environment (IDE)

Breakpoints

A breakpoint is an instruction set within an IDE (such as Visual Studio Code or PyCharm) that pauses program execution at a specific line, allowing the engineer to inspect the current state of all variables and memory at that exact moment. For example, when debugging a loop that is supposed to accumulate a total but is producing an incorrect result, placing a breakpoint at the beginning of each iteration allows the engineer to examine the running total before and after each calculation — pinpointing precisely where the logic diverges from the expected behaviour without having to add print statements throughout the code.

Watches

A watch is a debugging feature that continuously monitors the value of a specific variable as the program executes, updating in real time with each statement. This is particularly useful when a variable is modified across multiple functions or modules. For example, setting a watch on a total_price variable allows an engineer to observe exactly at which line — and within which function — an incorrect GST calculation is being applied, rather than manually tracing through the entire codebase to find the source of the discrepancy.

Single Line Stepping

Single line stepping (also known as "step-through" debugging) executes the program one statement at a time, pausing after each line. This allows engineers to trace the exact path of execution through complex control structures — such as nested conditionals or recursive functions — verifying that each branch evaluates as intended. For example, stepping through an IF/ELIF/ELSE chain confirms which condition is evaluating to True for a particular input, revealing logical errors in the control flow that would be completely invisible during normal, uninterrupted execution.

def process_input(value):
    try:
        n = int(value)
        if 1 <= n <= 100: return "Valid" # Boundary check
        else: return "Out of Range"
    except ValueError:
        return "Abnormal Data" # Handling faulty data

# Example testing
print(process_input(100))   # Boundary: Valid
print(process_input("ABC")) # Abnormal: Handled

Debugging output statements

The simplest tool is a temporary statement that prints a value at a chosen point. It works anywhere, including where no debugger is available, but you must remove the statements afterwards and it can flood the screen inside a loop. Label each output so you can find it:

def apply_discount(total, items):
    print(f"DEBUG apply_discount: total={total!r}, items={items!r}")
    if items >= 10:
        return total - total * 10 // 100
    return total

Interfaces between functions

The interface of a function is what it expects in (parameters) and what it gives back (return value). Many faults are not inside a function but in the hand-over between two of them: the wrong units, the wrong order of arguments, or the wrong type. To debug an interface, print or watch the values as they cross the boundary, before and after the call.

def format_dollars(cents):
    return f"${cents // 100}.{cents % 100:02d}"

total = 45.00                       # dollars, but the next function expects cents
total = apply_discount(total, 10)
print("DEBUG total after discount:", total)
print(format_dollars(total))

DEBUG total after discount: 41.0
Traceback (most recent call last):
  ...
ValueError: Unknown format code 'd' for object of type 'float'
(the exact traceback lines vary between Python versions)

The debugging output shows 41.0, a float in dollars, arriving where whole cents are expected. The fault is in the caller, which passed dollars, not in either function.

Debugging software in an IDE

An integrated development environment (IDE) such as Visual Studio Code, PyCharm or Thonny includes a debugger that combines the tools above in one window: breakpoints, stepping controls, a variables panel, a watch list and a call stack. In Visual Studio Code the usual keys are F9 to toggle a breakpoint, F5 to run or continue, F10 to step over a line and F11 to step into a function. Python also ships a text debugger: writing breakpoint() in the code, or running python -m pdb file.py, starts it, where n runs the next line, s steps into a call, c continues and p expression prints a value.

Worked example: finding a bug with a breakpoint and a watch

This function should return the average of the marks. The expected result for [80, 70, 90] is 80.0.

def average(marks):
    total = 0
    for i in range(1, len(marks)):
        total += marks[i]
    return total / len(marks)

print(average([80, 70, 90]))

53.333333333333336

The result is wrong but there is no error message, so this is a logic error. Put a breakpoint on the line total += marks[i] and add a watch on i and total. Continue to the breakpoint each time and record the watch values:

The first value added is 70, not 80. The loop starts at i = 1, so marks[0] is never counted: 160 ÷ 3 = 53.33. The fix is range(len(marks)), or range(0, len(marks)). The same session in Python’s text debugger, using b 4 to set the breakpoint on that line and p i, total to inspect:

(Pdb) b 4
(Pdb) c
> avg.py(4)average()
-> total += marks[i]
(Pdb) p i, total
(1, 0)
(Pdb) c
> avg.py(4)average()
-> total += marks[i]
(Pdb) p i, total
(2, 70)

Choosing Test Data

🎯 (SE-11-06, SE-11-07)

📌 Determine sets of suitable test data

• boundary values
• path coverage
• faulty and abnormal data

Good test data is chosen on purpose, not typed at random. A small, well-chosen set can find most errors. Imagine a program that accepts a mark from 1 to 100.

Test Data Selection

Boundary values

Boundary values are at the edges of what is valid. For every limit, test the value on it, the one just inside and the one just outside. For a mark from 0 to 100 that is −1, 0, 1 and 99, 100, 101. Most off-by-one errors, such as < written instead of <=, are only caught here. The boundaries between grade bands (49 and 50, 64 and 65, 84 and 85) need the same treatment.

Path coverage

Path coverage means the test data makes every route through the algorithm run at least once. Count the paths in the decision structure, then choose one input for each. This function has five paths (invalid, and four grades), so it needs at least five tests.

BEGIN Classify (mark)
    IF mark < 0 OR mark > 100 THEN
        RETURN "Invalid"
    ELSE
        IF mark >= 85 THEN
            RETURN "High"
        ELSE
            IF mark >= 65 THEN
                RETURN "Medium"
            ELSE
                IF mark >= 50 THEN
                    RETURN "Pass"
                ELSE
                    RETURN "Fail"
                ENDIF
            ENDIF
        ENDIF
    ENDIF
END Classify (mark)

Faulty and abnormal data

Abnormal data is the wrong type or is outside the range the program should accept, such as the text "fifty", -5 or 1000 for a mark. Faulty data is data that contains errors: a missing field, a corrupted value, or entries that contradict each other. A robust program rejects or reports both instead of crashing or accepting them.

Worked example: a test table for Classify

Every one of the five paths is covered, and every boundary is tested on both sides. Running the tests in Python, with the function written to check the type first:

def classify(mark):
    if isinstance(mark, bool) or not isinstance(mark, int):
        return "Invalid"
    if mark < 0 or mark > 100:
        return "Invalid"
    elif mark >= 85:
        return "High"
    elif mark >= 65:
        return "Medium"
    elif mark >= 50:
        return "Pass"
    else:
        return "Fail"

tests = [(-1, "Invalid"), (0, "Fail"), (1, "Fail"), (49, "Fail"), (50, "Pass"),
         (64, "Pass"), (65, "Medium"), (84, "Medium"), (85, "High"), (100, "High"),
         (101, "Invalid"), ("fifty", "Invalid"), (None, "Invalid"), (72.5, "Invalid")]
failed = 0
for mark, expected in tests:
    actual = classify(mark)
    if actual != expected:
        failed += 1
        print("FAIL", repr(mark), "expected", expected, "got", actual)
print(len(tests), "tests run,", failed, "failed")

14 tests run, 0 failed

If the developer had written mark > 50 for the Pass band, test 5 would print FAIL 50 expected Pass got Fail, and the boundary test would have found the fault that a typical mark such as 72 never would.

The canteen program’s tests

Typical Errors and Their Causes

🎯 (SE-11-06, SE-11-07)

📌 Determine typical errors experienced when developing code, including syntax, logic and runtime, and explain their likely causes

Understanding common error types helps programmers identify and fix problems systematically:

What the computer reports

Each type of error appears at a different time, so a different tool finds it.

Real error messages and their causes

The last line of a Python error message names the type of error and describes it. The wording can differ slightly between versions.

A logic error worked through

The program below runs without complaint, yet the answer is wrong. A student wants the average of two marks.

mark1 = 70
mark2 = 80
average = mark1 + mark2 / 2
print(average)

110.0

The expected answer is 75.0. Division is done before addition, so Python calculates 70 + (80 / 2). The cause is operator precedence; the fix is brackets: (mark1 + mark2) / 2. Other common causes of logic errors are off-by-one loops, the wrong comparison operator (< for <=), a variable not reset before a loop, and a condition that can never be true.

Spot the error