What is a 'Return Value'?

A return value is the data sent back from a function to the point where the function was called. It allows the result of a subprogram's calculation to be used in further processing.

What is the primary difference between a function and a procedure?

A function returns a value to the calling program, whereas a procedure simply executes a block of code without returning a result. Functions are typically used in assignments or calculations, while procedures are used for standalone tasks.

How do formal parameters differ from actual arguments?

Formal parameters are the variables listed in the subprogram's definition (the 'placeholders'), while actual arguments are the real values or variables passed into the subprogram when it is called.

What is the difference between local and global variables in the context of subprograms?

Local variables are declared inside a subprogram and exist only during its execution, while global variables are declared outside and can be accessed by any part of the program. Using local variables prevents unintended side effects in other parts of the code.

What happens if you try to access a local variable from the main program?

The program will throw an error (such as a NameError) because the local variable's scope is restricted to the subprogram where it was defined. Once the subprogram finishes, its local variables are removed from memory.

What is a common logical error when passing multiple arguments to a subprogram?

Passing arguments in the incorrect order is a frequent mistake. If a subprogram expects (width, height) and you pass (height, width), the code may run without crashing but will produce incorrect results.

Why is it an error to treat a procedure like a function in an assignment statement?

Because a procedure does not return a value, attempting to assign its 'result' to a variable (e.g., x = myProcedure()) will result in the variable being empty or null, which can crash later parts of the program.

Define 'Modularity' in computer science.

Modularity is the software design technique of separating program functionality into independent, interchangeable modules (subprograms). This makes the code easier to understand, test, and maintain.

What does it mean to 'call' a subprogram?

Calling a subprogram means invoking its name in the code to trigger its execution. When a call occurs, the program pauses its current task, runs the subprogram, and then returns to the next line of the original code.

How do subprograms improve program maintainability?

They centralize logic; if a specific calculation or process needs to change, you only update the code inside the subprogram once. This change automatically applies to every part of the program that calls that subprogram.

Sub Programs | OCR GCSE Computer Science

1. Definition & Core Concepts

A subprogram is a self-contained sequence of instructions that performs a specific task and can be 'called' or invoked from other parts of a program.
The two primary types of subprograms are functions and procedures, which differ based on whether they provide a resulting value back to the calling code.
Parameters are special variables defined in the subprogram's header that act as placeholders for the data the subprogram needs to perform its task.
Arguments (or actual parameters) are the specific values or variables passed into these placeholders during a subprogram call.

Diagram showing the flow of control between a main program and a subprogram, illustrating the call with arguments and the return of control or values.

2. Underlying Principles

Modularity: This principle involves decomposing a large, complex problem into smaller, discrete modules that are easier to develop, test, and debug independently.
Code Reusability: Subprograms allow developers to write a logic block once and execute it multiple times throughout the application, reducing the overall code volume and potential for errors.
Abstraction: By using subprograms, a programmer can use a complex operation (like calculating a square root) by simply calling its name, without needing to understand the internal mathematical implementation.
Maintainability: When a specific task needs to be updated or fixed, changes only need to be made in one location (the subprogram definition) rather than every instance where the task is performed.

3. Methods & Techniques

Defining a Subprogram

To create a subprogram, you must specify its identifier (name), its parameters (inputs), and the block of code it contains.
In many languages, the keyword function or def is used to start the definition, followed by parentheses containing any required parameters.

Calling a Subprogram

A subprogram remains dormant until it is 'called' by its name followed by parentheses containing the actual data (arguments) to be processed.
Example: result = calculateTax(50000, 0.2) invokes the subprogram with specific values.

Returning Values

Functions use a return statement to send a specific result back to the calling line of code, effectively replacing the function call with the returned value.

4. Key Distinctions

The fundamental difference between subprogram types lies in their output behavior and how they are used in expressions.

Feature	Function	Procedure
Return Value	Always returns a value to the caller	Does not return a value
Usage	Used in assignments or expressions (e.g., $y = f(x)$ )	Used as a standalone instruction
Purpose	Typically used for calculations or data retrieval	Typically used for actions (e.g., printing, saving)

Local vs. Global Scope: Variables declared inside a subprogram are local and cannot be accessed outside it, whereas global variables are accessible throughout the entire program.

5. Exam Strategy & Tips

Check the Return Type: When asked to write a subprogram, identify if the task requires a result to be used later (Function) or just an action to be performed (Procedure).
Parameter Matching: Ensure that the number and data types of arguments passed during a call exactly match the parameters defined in the subprogram header.
Trace the Flow: In 'trace table' questions, remember that the program 'jumps' to the subprogram code and then 'jumps back' to the exact point where it was called once finished.
Naming Conventions: Use descriptive verbs for procedures (e.g., printReport) and nouns or descriptive results for functions (e.g., calculateTotal) to improve clarity.

6. Common Pitfalls & Misconceptions

Scope Errors: A common mistake is attempting to use a variable defined inside a subprogram (local variable) in the main program, which results in an 'undefined' error.
Missing Return Statements: Forgetting the return keyword in a function will often result in the function returning null or None, breaking subsequent calculations.
Argument Order: Passing arguments in the wrong sequence (e.g., passing age where height is expected) will not always cause a crash but will lead to logical errors in the output.

Sub Programs

Summary

1. Definition & Core Concepts

2. Underlying Principles

3. Methods & Techniques

Defining a Subprogram

Calling a Subprogram

Returning Values

4. Key Distinctions

5. Exam Strategy & Tips

6. Common Pitfalls & Misconceptions

Sub Programs

Summary

1. Definition & Core Concepts

2. Underlying Principles

3. Methods & Techniques

Defining a Subprogram

Calling a Subprogram

Returning Values

4. Key Distinctions

5. Exam Strategy & Tips

6. Common Pitfalls & Misconceptions