Loading…
Free A-Level Computer Science guide
Connect control structures to modular programs, distinguish local and global state, reason precisely about parameters and use debugging evidence. Covers OCR H446 Paper 2 section 2.2.1(a, c–e).
Content owner: Michael Print · Written for A-Level learners · Checked against official specifications
Sequence executes steps in order; branching chooses a path using a condition; iteration repeats a group of steps. Modularity groups related work into components with clear interfaces so they can be understood, reused and tested separately.
A variable's scope determines where its name can be accessed. Parameter passing determines how a subprogram receives arguments and whether changes can affect the caller. Explain the rules for the language or pseudocode being used.
You should be able to trace an if inside a loop and recognise a Python list. The selection and loops guide and lists and functions guide cover these foundations.
This original program counts scores at or above a threshold, then displays the count. The counting component accepts a list of numeric scores and a numeric threshold.
PASS_MARK = 60
total = 100
def count_passes(scores, threshold):
total = 0
for score in scores:
if score >= threshold:
total += 1
return total
def show_report(count):
print("Passes:", count)
result = count_passes([35, 70, 80], PASS_MARK)
show_report(result)
print(total)| Construct | Where it appears | Purpose |
|---|---|---|
| Sequence | Initialise total before looping; return after looping | Start from zero and return the final count |
| Iteration | for score in scores | Visit each score once |
| Branching | if score >= threshold | Increment only for a passing score |
A counted loop suits a known collection. A condition-controlled loop suits a task such as reading attempts until a correct answer is entered, provided its condition can eventually become false. Nesting puts one construct inside another: this program evaluates a branch on each loop iteration.
Worked example
scores refers to [35, 70, 80]; threshold receives the argument 60.count_passes() creates its own total, starting at zero.return total ends the call with result 2; the main program stores it in result.Passes: 2, then 100. The module-level total was not changed by assigning the function's local name.Passing the threshold makes the dependency explicit: the same function can use 50 or 70 without changing its body.
These are the usual examination roles. Python uses def for both.
Python defines both using def. A Python call that reaches the end without an explicit return expression still returns None. Printing is a side effect; it does not return the printed message to the caller.
Local names reduce accidental interference between components. A module-level global can hold shared configuration, but changing shared global state makes a component depend on earlier calls.
In Python, rebinding a module global inside a function requires global. Passing a parameter and returning a result often makes the state easier to follow.
Modularity supports focused testing: test the count without reading console output, then test the display separately. It also has costs: interfaces must agree, too many tiny components can obscure the flow, and a bug in a shared component affects every caller.
| Model | What the subprogram receives | Effect of assigning its parameter |
|---|---|---|
| By value | A copy of the argument value | Does not reassign the caller's variable |
| By reference | Access to the caller's variable/storage location | Can change the caller's variable |
For reference-valued objects, copying a reference by value can leave two names referring to the same mutable object. A by-value call does not automatically copy all the data inside that object.
This teaching pseudocode uses explicit VALUE and REFERENCE annotations to define its rules. They do not claim an OCR pseudocode syntax requirement.
PROCEDURE addByValue(VALUE number)
number <- number + 1
ENDPROCEDURE
PROCEDURE addByReference(REFERENCE number)
number <- number + 1
ENDPROCEDURE
score <- 30
addByValue(score)
OUTPUT score // 30
addByReference(score)
OUTPUT score // 31The value parameter's private number becomes 31, but the caller's score stays 30. The reference parameter accesses the caller's score, so its later assignment changes that score to 31.
Worked example
def change(score, labels):
score = score + 1
labels.append("B")
labels = ["replacement"]
score = 30
labels = ["A"]
change(score, labels)
print(score)
print(labels)score + 1 produces an integer value 31. Assigning it binds the local parameter to that value; the caller's score remains 30.append("B") changes the shared list itself. The caller can see ["A", "B"].["replacement"] makes only the local parameter refer to a different list. It does not replace the caller's binding.The output is 30 then ['A', 'B']. Python's argument model is often called object sharing, or passing object references by value.
Assigning to a parameter cannot traditionally reassign the caller's variable as a by-reference parameter could. Trace rebinding separately from mutation of the shared object.
An integrated development environment brings tools such as a source editor, syntax highlighting, completion, execution and a debugger together. Error indicators can reveal syntax problems. A program that runs and produces the wrong result needs a logic investigation; highlighting cannot prove it correct.
def count_passes_bug(scores, threshold):
count = 0
for i in range(len(scores) - 1):
if scores[i] >= threshold:
count += 1
return count
print(count_passes_bug([35, 70, 80], 60))Worked example
len(scores) (3) and count (0).i = 0 and i = 1. Score 70 increases count to 1. There is no visit to i = 2.range(3 - 1) gives 0 and 1 because Python excludes the upper endpoint.range(len(scores)), or iterate directly with for score in scores. Check the original list, [80] (1), [] (0) and [59, 60] (1).Test results check observed behaviour; the debugger explains how it arose.
These five original questions total 19 marks. Marking guidance is indicative and independently written.
For count_passes([60, 59, 90], 60), state the returned value. Identify one instance each of sequence, iteration and branching in the function.
Indicative answer:
for loop visits the scores (1).if increments only when a score meets 60 (1).The boundary score 60 counts as a pass.
Give both output lines from the complete score program. Explain why the final line is not the count returned by the function.
Indicative answer:
Passes: 2 (1).100 (1).total is local to that call (1).total used by the final print (1).Equal spelling does not make them one variable.
Give both output lines from change() and its main program. Explain why appending “B” affects the caller's list but assigning “replacement” does not replace that list.
Indicative answer:
30 (1).['A', 'B'] (1).append mutates the list object also referenced by the caller (1).Describe a debugger action that would expose the faulty loop's missing last item, explain the incorrect bound, supply a correction and give a boundary test with its expected result.
Indicative answer:
i, score and count (1).range(len(scores)) or equivalent direct iteration (1).[80] with threshold 60; the expected count is 1 (1).Accept another last-item-only pass test whose expected value exposes the same error.
Distinguish the roles of count_passes() and show_report(). Explain one benefit of keeping them separate.
Indicative answer:
Python's implicit None return is compatible with this procedure role.
Checked against OCR H446 version 3.0 (2026), 2.2.1(a, c–e): constructs, global/local variables, modularity, functions/procedures, parameters and IDE use. Recursion in (b) and object-oriented techniques in (f) need their own resources.
The parameter pseudocode defines its own annotations; the Python examples use Python's documented object model.
These are independently written explanations and practice questions. CompSciTutoring.co.uk is not affiliated with or endorsed by an examination board. The marking guidance is indicative; always check the syllabus for your examination year.
Found an error? Email a correction.
Use the free examples first, then explore one-to-one tuition if guided practice would help.