Subroutines, Local and Global Variables (AQA A-Level Computer Science): Revision Notes

Subroutines, Local and Global Variables

Introduction to subroutines

In programming, a subroutine is a self-contained block of code that carries out one or more specific tasks. Think of subroutines as mini-programs within your main program. They help break down complex problems into smaller, more manageable pieces.

Subroutines are sometimes called algorithms when they describe a step-by-step process. Each subroutine must have a unique name (identifier), which allows you to call it whenever needed during program execution.

The key characteristic of a subroutine is that it performs a specific task and can be called multiple times throughout your program using its unique name.

How subroutines work

Imagine you're writing a program to manage a file system with options to add, amend, or delete records. Rather than writing all the code in one long sequence, you would create separate subroutines for each task:

Subroutine MainMenu
    Input Selected
    If Selected = "Add" Then Subroutine AddRecord
    If Selected = "Amend" Then Subroutine AmendRecord
    If Selected = "Delete" Then Subroutine DeleteRecord
End Subroutine
:
Subroutine AddRecord
    'Code to add a new record to a file
End Subroutine
:
Subroutine AmendRecord
    'Code to locate and amend an existing record
End Subroutine
:
Subroutine DeleteRecord
    'Code to delete an existing record
End Subroutine

In this example, when the variable Selected is set to "Add", the program calls the AddRecord subroutine. This modular approach makes your code much easier to understand and maintain.

Events and subroutines

An event is something that occurs during program execution that triggers a particular subroutine. For example, clicking a button in a graphical user interface is an event that might trigger a subroutine to execute.

Benefits of using subroutines

Breaking your program into manageable subroutines offers several important advantages:

• Reusability: Subroutines can be called multiple times using their unique name, eliminating the need to write the same code repeatedly
• Overview: They provide a clear structure that helps you understand how the program fits together
• Top-down development: You can design the overall structure first, then fill in the details of each subroutine later
• Testing and debugging: Each subroutine is self-contained, making it easier to test and fix errors in isolation
• Collaboration: Different programmers can work on different subroutines simultaneously in large projects

Modules

As programs grow more complex, related subroutines can be grouped together into modules. A module contains several subroutines that work together, and multiple modules combine to form the complete program. This adds another layer of organization to your code structure.

Functions

While subroutines perform tasks, functions are a special type of subroutine that perform a task and then return a value back to the calling code.

Think of a calculator as an analogy. Modern calculators have numerous built-in functions:

• Square function ($x^2$)
• Square root function ($\sqrt{x}$)
• Trigonometric functions (sin, cos, tan)

When you enter a number and press a function key, the calculator performs a calculation and returns the result.

How functions work in programs

A function in a computer program works similarly to calculator functions. You supply the function with data (input), and it returns a value (output) based on that data.

Functions aren't limited to numerical data. You could create a function that:

• Counts how many times the letter 'h' appears in a block of text
• Checks whether a file has read/write or read-only access permissions
• Validates user input

Benefits of functions

Functions provide two main benefits:

1. Code simplification: Some processes are complex and require many lines of code, but ultimately produce a single result. Placing this complex code in a function and calling it from your main program keeps the main program cleaner and easier to understand. If you need to modify the function, you only need to locate and change it in one place.

2. Code reuse: If you need to perform the same calculation or process in multiple places throughout your program, you write the code once as a function. Then you simply call that function from various locations. This keeps your program smaller and more maintainable. When you need to alter how the function works, you only modify one version of it.

Functional programming

Functional programming is a programming paradigm that relies exclusively on functions to create programs. This approach has advantages in certain types of applications. You'll learn more about functional programming in later chapters.

Parameters and arguments

For subroutines and functions to operate effectively, you need a mechanism to control what data they work with. This is achieved through parameters and arguments.

Block interfaces

Because subroutines are called from elsewhere in your program (external to the current code), there must be a mechanism to ensure the program handles the data transfer correctly. This mechanism is called a block interface.

Local variables

When you split your program into multiple subroutines and functions, you must decide on the scope of any variables you create. The scope determines where in your program a variable can be accessed and used.

A local variable is a variable that can only be used within the specific subroutine or function where it was created. It's not accessible from other parts of the program.

Advantages of local variables

Using local variables wherever possible is considered good programming practice for several reasons:

Variable state and side effects

Variables change their values throughout program execution. When subroutines pass values between each other, changes made in one subroutine can affect variables in another. This is called a side effect.

Declaring local variables

The syntax for declaring local variables varies by programming language:

Visual Basic:

Dim Age As Integer

This declares a local variable called Age of integer type.

Python: By default, all variables in Python are assumed to be local when they are defined within a function. You don't need special syntax to declare them as local.

Password = "password"

When written inside a function, this creates a local variable called Password.

Global variables

A global variable is a variable that can be accessed from anywhere in the program. It's available to all subroutines and functions throughout the entire application.

When to use global variables

You should only use a global variable when it genuinely needs to be accessible throughout your entire program.

Declaring global variables

Different programming languages use different syntax to indicate whether a variable is local or global:

Visual Basic: Global variables are declared as public:

Public Password As Text

This declares a global variable called Password of text type.

Python: In Python, you must explicitly tell the system to make a variable global using the global keyword:

global Password

This declares Password as a global variable. Without the global keyword, Python assumes the variable is local.

Some other languages: In certain programming languages, if you declare a variable outside any subroutine or function, it is automatically assumed to be global. You must be careful with variable declarations in such languages to ensure variables have the intended scope.

Example: Visual Basic code with mixed variable scopes

Public Password As String
Private Sub CalculateMathsGrade
    Dim Score As Integer
    Dim Grade As String
    If Score > 50 then
        Grade = "Pass"
    Else
        Grade = "Fail"
End Sub
Private Sub CalculateEnglishGrade
    Dim Score As Integer
    Dim Grade As String
    If Score > 50 then
        Grade = "Pass"
    Else
        Grade = "Fail"
End sub

Exception handling (A-level only)

Sometimes a subroutine needs to stop executing because an exceptional circumstance occurs that causes an error. This doesn't always mean something unexpected has happened; it simply means an event has occurred that requires the current subroutine to pause or stop.

The exception handling process

If a program cannot handle ('catch') an error, it may produce a fatal error, causing the entire program to stop running immediately.

To prevent fatal errors, you implement exception handling code. These are often called catch blocks - specific sections of code that are triggered in response to particular errors.

When an exception occurs, the normal flow of the program is interrupted:

Expected vs unexpected exceptions

Expected exceptions: These are errors you anticipate might happen and write code to handle. For example, checking for division by zero before performing a calculation.

Unexpected exceptions: These are errors you didn't anticipate. If your code doesn't have a handler for an unexpected exception, it may result in a fatal program error.

Remember!