20. Further Programming

Browse all infographics →

Dotted terms are defined in the glossary.

• Exception handling — TRY … EXCEPT … ENDTRY

  Validation stops bad data getting in; exception handling catches the runtime errors that slip through — division by zero, a failed conversion, an index out of range — so the program keeps running.

  A2PseudocodeValidation, testing & exceptions 9618 §20.3
  Run

• Save records to a text file and load them back

  Write each record as one delimited line, then parse the lines back into an array of records.

  ASA2PseudocodeFile handling §4.1, §9.1
  Run

• Random-access file — SEEK, PUTRECORD, GETRECORD

  Records are stored at addresses; SEEK moves the file pointer, then read or write the record there.

  A2PseudocodeFile handling §9.2
  Run

• A class with a constructor, getter and setter

  The guide's PlayerClass: a PRIVATE attribute reached only through PUBLIC methods.

  A2PseudocodeObject-oriented programming §10.1
  Run

• Inheritance — Animal and Dog

  Dog INHERITS Animal, calls SUPER.NEW, overrides Speak and adds its own methods.

  A2PseudocodeObject-oriented programming §10.2
  Run

• Polymorphism — one Area() call, different shapes

  An array of Shape objects; each subclass overrides Area(), and the loop does not care which it is.

  A2PseudocodeObject-oriented programming §10.2
  Run

• Encapsulation — a bank account that protects its balance

  Balance is PRIVATE; Deposit and Withdraw validate every change. Try uncommenting the last line.

  A2PseudocodeObject-oriented programming §10.1
  Run

• Containment — a Car has an Engine

  One object stored inside another (has-a), as opposed to inheritance (is-a).

  A2PseudocodeObject-oriented programming §10.1–10.2
  Run

• A Stack class

  The stack ADT wrapped in a class: the array and Top are PRIVATE, so only Push/Pop can touch them.

  A2PseudocodeObject-oriented programming §10.1 · 9618 §19.1
  Run

• A2 Paper 4 — stock control with a Product class, files & exceptions

  A class with validation in its methods, an array of objects, the stock saved to a text file, then reloaded with TRY … EXCEPT protecting the program from a corrupt line.

  A2PseudocodeExam-style tasks §9.1, §10 · 9618 §20.3
  Run

• Validation loop — range and type checks

  Keep asking until the input is a whole number between 1 and 100. try/except catches the ValueError from int().

  O LevelASPythonValidation, testing & exceptions §7.3 ↔ Python, A2 §20.3
  Run

• try / except / finally — exception handling

  A2 §20.3: catch specific exceptions, use else and finally, raise your own. Compare with TRY … EXCEPT … ENDTRY.

  A2PythonValidation, testing & exceptions A2 §20.3 ↔ Python
  Run

• Records in a file — CSV with the csv module

  A list of dictionaries written and read back as CSV, the way Paper 4 file-handling questions expect.

  A2PythonFile handling §9 ↔ Python
  Run

• A class with private attributes, getters and setters

  Two underscores make an attribute private (name mangling). Access it through methods — encapsulation, the Paper 4 way.

  A2PythonObject-oriented programming §10.1 ↔ Python
  Run

• Inheritance and polymorphism

  A subclass calls super().__init__ and overrides a method; the same call behaves differently for each object.

  A2PythonObject-oriented programming §10.2 ↔ Python
  Run

• Containment — a class that holds other objects

  A Library object contains a list of Book objects (has-a), as opposed to inheritance (is-a).

  A2PythonObject-oriented programming §10 ↔ Python
  Run

• 9618 Paper 4: class + file + exception

  The three Paper 4 ingredients in one: a class with private attributes, objects saved to a file and read back, with try/except on the file.

  A2PythonExam-style tasks 9618 §19–20
  Run

• Immediate addressing

  The operand IS the value. LDM #25 puts 25 in ACC — no memory read happens in the execute stage.

  ASA2Addressing modes 9618 §4.2, §20.1
  Run

• Direct addressing

  The operand is the address of the value. LDD 200 reads memory location 200. Watch MAR/MDR in the execute stage.

  ASA2Addressing modes 9618 §4.2, §20.1
  Run

• Indirect addressing (LDI)

  The operand holds the address of the address. [200] = 300, so LDI 200 loads [300]. A pointer in assembly.

  ASA2Addressing modes 9618 §4.2, §20.1
  Run

• Indexed addressing (LDX) — walking an array

  Address = operand + IX. With IX = 0, 1, 2… LDX 300 visits 300, 301, 302 — how a loop reads an array.

  ASA2Addressing modes 9618 §4.2, §20.1
  Run

• Relative addressing (A2)

  The operand is an offset from the current instruction: JMP +2 skips the next instruction, LDD +3 reads the location three after this one. Position-independent code — §20.1.

  A2Addressing modes 9618 §20.1
  Run

• All five addressing modes in one program

  Immediate, direct, indirect, indexed and relative, one after another — the summary table you should be able to reproduce in Paper 3.

  A2Addressing modes 9618 §4.2, §20.1
  Run

• Sum an array — the working idiom

  Keep the loop counter in memory alongside IX: the counter is compared, IX does the indexing. Ends when COUNT = 0.

  ASA2Compare & jump 9618 §4.2
  Run

• Linear search through memory

  Search for 30 in an array of 5 using LDX; output Y if found, N if not. Change TARGET to try both paths.

  ASA2Compare & jump 9618 §4.2
  Run

• CMI — compare through a pointer

  CMI 200 compares ACC with the value at the address stored in 200 — indirect addressing for a compare.

  ASA2Compare & jump 9618 §4.2
  Run

• Print a string stored in memory

  Characters live at consecutive addresses, ending with 0. LDX + INC IX walks them until the terminator.

  ASA2Input & output 9618 §4.2
  Run

• Trace question: indirect and indexed together (A2)

  Paper 3 style: combine LDI, LDX and CMI and give the final contents of the registers.

  A2Exam-style traces 9618 §20.1
  Run

• A family tree — facts and simple queries

  Facts state what is true. A query with a constant asks yes/no; a query with a variable (capital letter) asks Prolog to find every value that makes it true.

  A2Facts & queries 9618 §20.1
  Run

• Capitals and continents

  Two-argument facts read as a relation. Ask in both directions — Prolog does not care which argument is the “input”.

  A2Facts & queries 9618 §20.1
  Run

• Conjunction — two goals in one query

  A comma means AND. Prolog solves the first goal, then the second with the same variable values, backtracking if the second fails.

  A2Facts & queries 9618 §20.1
  Run

• Rules — mother, father, grandparent

  A rule is true if its body is true. mother(M, C) :- parent(M, C), female(M). reads “M is the mother of C if M is a parent of C and M is female”.

  A2Rules 9618 §20.1
  Run

• Siblings — and why X \= Y matters

  Without X \= Y, everyone is their own sibling. Run both queries and compare. Duplicated answers (one per shared parent) are normal Prolog behaviour.

  A2Rules 9618 §20.1
  Run

• Several clauses for one predicate (OR)

  Two rules for can_drive: either condition makes it true. Prolog tries the first clause, then the second on backtracking.

  A2Rules 9618 §20.1
  Run

• Watch backtracking happen

  Run the query and open the Resolution tab: Prolog picks a colour, tries to satisfy the second goal, fails, goes back (REDO) and tries the next one.

  A2Rules 9618 §20.1
  Run

• ancestor/2 — the classic recursive rule

  Base case: a parent is an ancestor. Recursive case: a parent of an ancestor is an ancestor. Order of the clauses matters.

  A2Recursive rules 9618 §20.1
  Run

• Routes through a network

  Is there a path from one station to another? Directed edges plus a recursive route/2. Try a start with no outgoing edge.

  A2Recursive rules 9618 §20.1
  Run

• Left recursion — the infinite loop (this one is meant to fail)

  If the recursive call comes BEFORE the fact that makes progress, Prolog recurses forever. The Lab stops it with a depth error — reorder the goals in the second clause to fix it.

  A2Recursive rules 9618 §20.1
  Run

• Lists — [Head | Tail]

  A list is a head and a tail. Unification splits it: [H|T] = [a, b, c] gives H = a, T = [b, c].

  A2Lists 9618 §20.1
  Run

• member/2 and append/3

  Two built-ins you should be able to write yourself. member checks or generates; append joins, splits and even finds prefixes.

  A2Lists 9618 §20.1
  Run

• Recursing over a list — length, sum, count

  Base case on [], recursive case on [H|T]. Note that the arithmetic comes AFTER the recursive call so N1 has a value.

  A2Lists 9618 §20.1
  Run

• findall/3 — collect every answer in a list

  findall(Template, Goal, List) runs Goal for every solution and gathers the Template values. Then length/2 counts them.

  A2Lists 9618 §20.1
  Run

• reverse, last, nth1, sum_list, max_list

  Handy list built-ins — and how reverse is written with an accumulator.

  A2Lists 9618 §20.1
  Run

• is versus = — the most common A2 mistake

  = unifies structures; is evaluates. X = 2 + 3 leaves X as the term 2+3; X is 2 + 3 gives 5. The linter warns when a rule uses = with arithmetic.

  A2Arithmetic 9618 §20.1
  Run

• Factorial and Fibonacci

  Recursion with arithmetic. The guard N > 0 stops the recursion running below zero.

  A2Arithmetic 9618 §20.1
  Run

• Grades from marks — comparison operators

  =< and >= (not <= !), and a rule per band. The order of the guards keeps the bands from overlapping.

  A2Arithmetic 9618 §20.1
  Run

• “Arguments are not sufficiently instantiated” (meant to fail)

  Arithmetic needs values. In the second rule the recursive call comes after N is used — N1 has no value yet, so 'is' throws. Compare with the working rule.

  A2Arithmetic 9618 §20.1
  Run

• Negation as failure — \+

  \+ G succeeds if G cannot be proved. It never binds variables, so put \+ AFTER the goals that give its variables values.

  A2Negation & cut 9618 §20.1
  Run

• The cut — commit to the first answer

  ! stops Prolog looking for other clauses of this predicate once it passes. max/3 and classify/2 use it as an if-then; remove the cut from classify and watch a mark get two grades.

  A2Negation & cut 9618 §20.1
  Run

• If-then-else with -> ;

  ( Cond -> Then ; Else ) — the structured alternative to a cut.

  A2Negation & cut 9618 §20.1
  Run

• write/1, nl/0 and fail-driven loops

  Print every solution with a failure-driven loop: the query fails at the end on purpose, having printed on the way.

  A2Negation & cut 9618 §20.1
  Run

• bagof, setof and aggregate_all

  findall never fails and keeps duplicates; bagof groups by the free variable (one answer per group) and fails on nothing; setof sorts and removes duplicates. aggregate_all counts, sums or finds the max in one go.

  A2Lists 9618 §20.1
  Run

• format/2 — neat output

  format(Format, Args): ~w writes a term, ~a an atom, ~d an integer, ~2f a float to 2 places, ~n a newline, ~t~20| pads to column 20. The fail-driven loop prints a table.

  A2Negation & cut 9618 §20.1
  Run

• assert and retract — a counter that remembers

  The knowledge base can change while a query runs. retract removes the old fact, assert adds the new one — and the Lab keeps the change until you edit the code or press Restart session. Ask count(X) after a few increments.

  A2Negation & cut 9618 §20.1
  Run

• catch and throw — handling errors

  A division by zero or an unbound variable raises an ISO error term; catch(Goal, Pattern, Recovery) matches it. safe_divide turns the error into an atom instead of stopping the query. The last query throws on purpose and is not caught — this one is meant to fail.

  A2Negation & cut 9618 §20.1
  Run

• Atoms, strings and characters

  atom_length, atom_concat, sub_atom, upcase_atom, atom_chars, atom_codes, atom_number — and the double-quoted string type SWI-Prolog 7 introduced (a string never unifies with an atom).

  A2Lists 9618 §20.1
  Run

• Why SWI-Prolog says false. after the last answer

  Prolog only knows there is nothing left when no choice point remains. With first-argument indexing, parent(sonia, X) ends with a full stop; grade(85, G) leaves the other clauses to try, so SWI (and this Lab) print G = a ; false. Examiners accept both, but knowing why is A2 understanding.

  A2Negation & cut 9618 §20.1
  Run

• Exam: warehouse stock

  Numbered knowledge base as printed in Paper 3. Write the query to find items with fewer than 20 in stock, and the rule reorder(Item).

  A2Exam-style scenarios 9618 §20.1
  Run

• Exam: teachers, rooms and clashes

  Facts about lessons; a rule that finds two lessons in the same room at the same time. Typical “write the rule” question.

  A2Exam-style scenarios 9618 §20.1
  Run

• Exam: classifying animals

  Rules chained on rules — the expert-system style question. Ask what a given animal is and which animals are mammals.

  A2Exam-style scenarios 9618 §20.1, §18 AI
  Run

• Exam: students, marks and averages

  findall, sum_list and length together — “write a rule average(Subject, Avg)”.

  A2Exam-style scenarios 9618 §20.1
  Run

• BankAccount

  One class with a PRIVATE balance, a constructor, deposit/withdraw and a getter — the classic encapsulation question.

  A2A single class 9618 §20.1
  Open

• Student with getters and setters

  Why attributes are PRIVATE and accessed through public methods.

  A2A single class 9618 §20.1
  Open

• Shapes: inheritance and overriding

  Shape with Circle and Rectangle subclasses that override Area() — inheritance and polymorphism in one diagram.

  A2Inheritance 9618 §20.1
  Open

• Vehicles

  Vehicle → Car and Lorry; the subclass constructors call SUPER.NEW.

  A2Inheritance 9618 §20.1
  Open

• Employees and payroll (polymorphism)

  Employee with Pay() overridden by SalariedEmployee and HourlyEmployee — the same call, different calculation.

  A2Polymorphism 9618 §20.1
  Open

• Car contains an Engine

  Containment: a Car has an Engine attribute — a has-a relationship, not is-a.

  A2Containment 9618 §20.1
  Open

• Library: Book, Member, Loan

  Three classes where Loan contains a Book and a Member.

  A2Containment 9618 §20.1
  Open

• Read: Animal, Dog, Cat

  Pseudocode with inheritance and an overridden Speak() — draw the class diagram from it.

  A2Read the code → draw the diagram 9618 §20.1
  Open

• Read: a Stack class

  A class that wraps an array and TopPointer — the ADT as an object.

  A2Read the code → draw the diagram 9618 §20.1
  Open