Programming techniques and paradigms

9.1 · Free notes

Programming constructs, variable scope and parameter passing

Key points

• All programs are built from three constructs: sequence (statements in order), selection (IF/ELSE, CASE/switch) and iteration (loops). Examiners expect you to trace these accurately.
• Selection can be nested, and a CASE/switch statement is a tidier alternative to a long chain of IF/ELSE IF when comparing one variable with many values.
• Count-controlled iteration (FOR) runs a known number of times. Condition-controlled iteration has a pre-condition test (WHILE, may run zero times) or a post-condition test (REPEAT...UNTIL / DO...WHILE, always runs at least once).
• A variable can change during execution, while a named constant is assigned once and cannot change. Constants improve readability and maintainability because a value such as VAT_RATE is changed in one place only.
• Scope is the part of a program where an identifier can be accessed. A local variable is declared inside a subroutine and exists only while it runs. A global variable is accessible throughout the program.
• Prefer local variables: they stop accidental changes from elsewhere (side effects), allow the same name to be reused safely, save memory because they are destroyed on return, and make subroutines easier to test and reuse.
• Global variables make code harder to debug and maintain because any subroutine can change them. They create hidden dependencies between modules and reduce reusability.
• If a local variable has the same name as a global one, the local shadows the global inside the subroutine. The global's value is unchanged outside.
• A parameter is the name in the subroutine definition (formal parameter). An argument is the actual value passed in the call (actual parameter).
• Pass by value passes a copy of the argument, so changes inside the subroutine do not affect the caller's variable. Pass by reference passes the address, so the subroutine works on the original and changes persist.
• Each call creates a stack frame on the call stack. It holds the parameters, local variables and return address, and is removed when the subroutine returns.
• Exam technique: when tracing, use a trace table with one column per variable and update it on every iteration. Check loop boundaries (off-by-one errors) and whether the loop test is before or after the body.

In more detail

• Worked nested loops: printing a 3 × 3 multiplication grid uses a loop for rows inside a loop for columns.
• Worked global variables: changing a global counter inside a Python function needs a global declaration; passing it in and returning it is cleaner.
• Worked mutable arguments: passing a list to a function that appends to it changes the original list, because lists are mutable.
• Worked CASE: CASE day OF 1: "Mon", 2: "Tue", … is clearer than a long chain of IF statements.
• Worked loop types: FOR is count-controlled; WHILE tests before each pass; REPEAT … UNTIL tests after, so it always runs at least once.