AQA A-Level Computer Science AS Paper 1, June 2025: Question 4

✅ Acceptable Answers (1 Mark)

• A named / callable (out-of-line) block of code.
• A self-contained section of code that can be executed by writing its name in a program statement.

💡 Key Knowledge

A subroutine is an out-of-line unit of execution. In most high-level languages, subroutines take the form of either:

• Procedures: execute a set of instructions without returning a direct value to the calling statement.
• Functions: execute instructions and must return a value back to the call site.

🧠 Exam Technique

Don't be vague. Avoid phrases like "a part of a program" or "a line of code". The essential technical element examiners look for is that it is a named block of instructions that is called / executed when referenced.

❌ Common Errors

• Confusing a subroutine with a loop or selection statement (e.g. saying "code that repeats until finished").
• Stating an advantage (e.g. "it saves memory") instead of defining what it actually is.

✅ Acceptable Points (Any 3, 1 Mark Each)

• Code reusability: Easier to re-use code across different parts of the project or future programs.
• Maintainability & Debugging: Easier to test, debug, update, and maintain isolated units of code.
• Readability & Structure: Easier to understand; supports a structured, top-down modular approach.
• Development speed: Write less code / faster to build solutions.
• Team collaboration: Facilitates multiple programmers working simultaneously on separate modules.
• Reduced side effects / Memory efficiency: Enables the use of local variables, which only occupy memory while the subroutine executes.

❌ Common Errors & Lost Marks

• Vague one-word points: Writing just "easier", "faster", or "saves time" without explaining what is easier (e.g., must specify "easier to debug" or "faster development").
• Repeating the same benefit: Giving "easier to test" and "easier to find bugs" as two separate points—examiners consider these the same marking point.
• Claiming it makes the program run faster—subroutine calls actually incur a microscopic call-stack overhead; the speed advantage lies in developer productivity.

✅ Acceptable Points (Any 2, 1 Mark Each)

• Eliminates global variables: Makes the subroutine self-contained / encapsulated, reducing unwanted side effects.
• Flexibility & Reusability: Allows the same subroutine to operate on different values, expressions, or variables each time it is called.
• Portability: Makes it easier to reuse the subroutine in a completely different program without dependencies.
• Independent testing: Enables simple isolated unit testing by passing test values directly into arguments.
• Code clarity: Makes it explicit and clear which inputs from outside the subroutine are being manipulated inside.

💡 Key Knowledge: Parameters vs. Global Variables

Without parameters, a subroutine would either:

• Always execute using fixed, hard-coded values (inflexible).
• Rely on global variables, meaning any other routine could accidentally mutate that data, leading to obscure bugs and tight coupling.

Parameters create clean, well-defined interfaces for your code blocks.

🧠 Exam Technique: Focus on the "Improvement"

The command word is describe how parameters improve effectiveness. Don't just define what a parameter is (e.g. "it is a value passed in"). State the direct benefit: "It allows the subroutine to be called with different arguments..." or "It reduces reliance on global variables, making the code self-contained."

❌ Common Errors

• Confusing parameters (the variable definition in the subroutine header) with arguments (the actual value passed in during the call)—though acceptable in general descriptions, maintaining precise terminology is best practice.
• Claiming parameters return values—parameters are inputs; return statements deliver outputs.