Structured Programming

Imagine one enormous block of code that reads input, validates it, calculates totals, prints reports and saves files — all jumbled together. It is hard to read, hard to test, and a single change risks breaking everything.

Structured (modular) programming solves this by dividing the program into small, named, single-purpose modules. Each module does one job and can be:

• reused — written once, called many times (no copy-paste);
• tested on its own — easier to find and fix faults;
• understood quickly — a main program of meaningful calls reads like a summary;
• shared out — different people can work on different modules at once.

There are two kinds of module in 9618 pseudocode:

Module	Returns a value?	How you invoke it
Procedure	No — it does a task	as a statement: CALL Name(...)
Function	Yes — a single value	inside an expression: x ← Name(...)

The rest of these notes builds up both, plus how data is passed in and out.

A procedure is a named block of code that carries out a task. It does not return a value, so you invoke it as a statement using the keyword CALL.

PROCEDURE PrintHeading()
   OUTPUT "MENU"
   OUTPUT "====="
ENDPROCEDURE

CALL PrintHeading()

When the program reaches CALL PrintHeading(), control jumps into the procedure, runs its body, then returns to the line straight after the CALL:

Use a procedure when the action has nothing to give back — for example printing a heading, saving a record, or clearing the screen.

A procedure with no inputs still has empty brackets (). Procedures can also take parameters (see §4) so they work on different data each time.

A function is a named block that performs a calculation and returns a single value. Its header ends with RETURNS , and its body must contain a RETURN statement that sends the value back.

FUNCTION Square(p : INTEGER) RETURNS INTEGER
   RETURN p * p
ENDFUNCTION

The key idea: a function is not called on its own line. It is used inside an expression, and its return value replaces the call:

Result ← Square(5)      // Square(5) becomes 25, so Result holds 25
OUTPUT Square(3) + 1    // becomes 9 + 1 = 10
IF IsValidMark(Score) = TRUE THEN ...

So you can think of Square(5) as standing for the number 25 once it has run.

Use a function when you need a value — for a calculation, an assignment, an OUTPUT, or a condition. A function that answers a yes/no question should RETURNS BOOLEAN and return TRUE or FALSE.

Procedure vs function in one line: a procedure does something (no value, use CALL); a function gives back a value (use it in an expression).

Routines become reusable when they work on different data each time. Data is passed in through parameters.

• A parameter is a variable named in the header (the definition). It says what kind of value the routine expects.
• An argument is the actual value (or variable) supplied at the call. It is copied or referenced into the matching parameter.

FUNCTION Square(p : INTEGER) RETURNS INTEGER   // p is the PARAMETER
   RETURN p * p
ENDFUNCTION

Result ← Square(5)     // 5 is the ARGUMENT passed into p

A routine can take none, one, or many parameters. Each parameter needs a data type:

PROCEDURE PrintHeading()                          // none
FUNCTION Square(p : INTEGER) RETURNS INTEGER       // one
PROCEDURE Adjust(BYVAL a : INTEGER, BYREF b : INTEGER)  // many, mixed

The arguments at the call must match the parameters in order, number and type.

Interface: the header — the routine's name, its parameters (and how they are passed), and what it returns — is called its interface. The rest of the program only needs the interface to use the routine; it does not need to know the code inside. This is the idea of abstraction.

When an argument is passed in, there are two ways it can be done. This is the single most-tested idea in 11.3.

BYVAL — pass by value: the routine gets a copy of the argument. Changing the parameter changes only the copy, so the caller's original variable is untouched after the call.

BYREF — pass by reference: the routine gets a reference to the caller's actual variable (its memory location). Changing the parameter changes the original, so the caller sees the change after the call.

In Cambridge pseudocode the default is BYVAL unless BYREF is written explicitly.

Trace this procedure with x ← 1 and y ← 1, then CALL Adjust(x, y):

When to use which:

• BYVAL — the routine only needs to read the value and must not change the caller's data (most functions).
• BYREF — the routine must update the caller's variable, e.g. a Swap procedure, or returning more than one value to the caller.

Real Paper 2 questions ask you to design a solution from modules. The skill is choosing the right kind of module for each job:

• a step that produces a value → a function (used in an expression);
• a step that performs an action with nothing to return → a procedure (invoked with CALL).

Task: read a price, apply a 20% discount, then print it.

FUNCTION ApplyDiscount(price : REAL) RETURNS REAL
   RETURN price * 0.8
ENDFUNCTION

PROCEDURE ShowPrice(BYVAL p : REAL)
   OUTPUT "Price: $", p
ENDPROCEDURE

// main program — just coordinates the modules
INPUT Cost
Final ← ApplyDiscount(Cost)    // function: value used in an expression
CALL ShowPrice(Final)          // procedure: action, no return value

Notice how the main program reads almost like plain English. Each module:

• does one job, so it can be tested alone;
• could be reused elsewhere (e.g. ApplyDiscount in any pricing screen);
• can be rewritten internally without breaking the rest of the program, as long as its interface stays the same.

That is the whole point of structured programming: manage complexity by building from small, well-defined, reusable parts.