Key vocabulary

Combining records and file handling — the second full cycle

Why this lesson builds on SDD19, not replaces it

SDD19 deliberately kept its scenario narrow — one array, no records, no files — so the five-stage cycle itself could be learned without extra complexity. This lesson adds back exactly what SDD19 left out: arrays of records (SDD6, SDD15) and file handling (SDD11, SDD12), combined together in one program. This combination — reading records from a file, searching or processing them with a standard algorithm, and writing the changed records back — is the closest rehearsal this course has for the actual assignment (Task 1, 25 marks, 6 supervised hours, Feb–Mar 2027), which expects exactly this kind of structured, persistent, file-backed program.

The problem for this lesson

A school library wants a small program to manage its book records: each book has a title, an author, and a number of copies available. The records are stored in a CSV file so they persist between runs. The program should read the records, find a specific book by title using a standard algorithm, issue a loan by reducing that book's copies by one (only if a copy is actually available), and then write the updated records back to the file so the change is saved.

Stage 1 — Analysis

The functional requirements for this problem: read an array of book records (title, author, copies) from a CSV file; find a specific book by title; reduce a found book's copy count by one when a loan is issued, but only if copies are available; and write the updated records back to the file so the change persists. Each of these becomes a specific, testable requirement — notably, "only if copies are available" is itself a functional requirement, not just a nice-to-have, since a program that lets copies go negative has failed this requirement even if it never crashes.

Stage 2 — Design

The design now needs to show file input and output alongside the function/procedure calls already familiar from SDD19: readBooks(filename) (a function, reads the file and returns an array of records); findBookByTitle(books, title) (a function, the standard linear search algorithm reused from SDD13/15, now searching a record field); issueLoan(books, index) (a procedure, updates a record's field in place); and writeBooks(books, filename) (a procedure, writes the array back to the file). Sketching this data flow — file → array of records → search → update → file — before coding prevents a common design gap: forgetting that writeBooks needs to run after issueLoan, not before, or the change is never actually saved.

Stage 3 — Implementation

Implementation combines three previously separate skills into one program: file reading (SDD11) builds the array of records; the linear search standard algorithm (SDD13, extended to records exactly as in SDD15) finds the right one; and file writing (SDD12) saves the result. The record itself is implemented as an @dataclass, consistent with every records lesson since SDD6. Note that issueLoan modifies a record's field directly (books[index].copies = books[index].copies - 1) — this only works correctly because findBookByTitle returned an index, not a copy of the record, exactly the same design point SDD15 made about minimum/maximum-finding on records.

Stage 4 — Testing

Testing this program needs the same three categories as every previous testing lesson (SDD16), but now with file-specific cases included: a normal case (a valid title with copies available); an extreme case (a valid title with exactly zero copies available, testing the "only if available" requirement at its boundary); and an erroneous case specific to file handling, such as an empty file, which SDD11's reading pattern is not designed to survive. A test plan that only tests "does it find the book" without testing the zero-copies boundary or the empty-file case would miss exactly the kind of requirement this problem depends on.

Stage 5 — Evaluation

Evaluation applies SDD18's five criteria to the combined program: fitness for purpose (does it correctly read, find, update, and save records); efficient use of coding constructs (is the standard linear search algorithm used appropriately, rather than something needlessly complex); usability (are loan confirmations and "no copies available" messages clear); maintainability (are the four sub-programs clearly named and each doing one job); and robustness (does the program survive an empty or malformed file, and does it correctly refuse a loan when no copies are available). This is a genuinely larger evaluation than SDD19's, since there are now four sub-programs and a file dependency to judge, not three sub-programs operating purely in memory.

Worked examples

Mystery of the Blue Loch,A. Ferguson,3
Highland Adventures,R. Bell,5
The Coding Puzzle,S. Mackay,0
Edinburgh Nights,L. Grant,2
The Silent Algorithm,K. Reid,4

from dataclasses import dataclass

@dataclass
class Book:
    title: str
    author: str
    copies: int

def readBooks(fileContents):
    books = []
    lines = fileContents.split("\n")
    for line in lines:
        fields = line.split(",")
        title = fields[0]
        author = fields[1]
        copies = int(fields[2])
        books.append(Book(title, author, copies))
    return books

def findBookByTitle(books, target):
    index = 0
    found = False
    while index < len(books) and not found:
        if books[index].title == target:
            found = True
        else:
            index = index + 1
    if found:
        return index
    else:
        return -1

def issueLoan(books, index):
    if books[index].copies > 0:
        books[index].copies = books[index].copies - 1
        print("Loan issued for", books[index].title,
              "- copies remaining:", books[index].copies)
    else:
        print("Cannot issue loan -", books[index].title,
              "has no copies available")

def writeBooks(books):
    lines = []
    for book in books:
        line = book.title + "," + book.author + "," + str(book.copies)
        lines.append(line)
    return "\n".join(lines)

Task Set A — Core questions

def countAvailableBooks(books):
    count = 0
    for i in range(len(books)):
        if books[i].copies > 0:
            count = count + 1
    return count

# countAvailableBooks(libraryBooks) returns 4
# (all books except "The Coding Puzzle", which has 0 copies)

Task Set B — Extension