Computer Science | Subprograms

👋 Welcome to the World of Subprograms!

Hello future Computer Scientists! This chapter is all about making your code cleaner, more efficient, and easier to manage. Imagine trying to read a 500-page book written as one giant paragraph—it would be impossible! Programs are the same.
We use subprograms (sometimes called subroutines) to break down massive tasks into small, logical, reusable chunks. This is one of the most important skills in programming!

Why Study Subprograms? (The Big Picture)

Subprograms help achieve modularity. Modularity simply means building something by putting together smaller, independent parts.

• Reusability: If you need to calculate VAT multiple times, you write the calculation code once inside a subprogram and call it whenever needed.
• Debugging (Error Fixing): If there's an error in calculating VAT, you only need to check the VAT subprogram, not the entire 1000 lines of code.
• Organisation: Makes code easy to read and manage, especially when working in a team.

---

1. The Two Types of Subprograms: Function vs. Procedure

In Computer Science, subprograms fall into two main categories based on what they do with the result of their actions:

1.1 Procedures (Subroutines)

A Procedure is a set of instructions designed to perform a specific task.

• Action Only: Procedures execute commands and do not send a value back to the main program (they don't "return" anything).
• Purpose: Often used for things that affect the outside world, like printing something to the screen, saving data to a file, or drawing a shape.

Analogy: The Remote Control

Think of pressing the "Mute" button on a TV remote. The procedure runs (the TV goes silent), but the button itself doesn't hand you back a value. It just completes an action.

Example (Pseudocode):

PROCEDURE DisplayWelcomeMessage()
OUTPUT "Welcome to the system!"
END PROCEDURE

1.2 Functions

A Function is a set of instructions designed to calculate and return a single value back to the main program.

• Calculation and Return: Functions must always result in, or "return," a specific data value (like a number, a string, or a boolean True/False).
• Purpose: Used primarily for calculations, comparisons, and retrieving specific data.

Analogy: The Cash Machine

When you ask a cash machine to calculate your new bank balance after a withdrawal, the machine (the function) calculates the amount and *returns* the final balance back to you (it displays the number).

Example (Pseudocode):

FUNCTION CalculateArea(Length, Width)
Area = Length * Width
RETURN Area
END FUNCTION

---

2. Parameters (Passing Data In)

If a subprogram is like a specialised machine, parameters are the raw materials you feed into it so it can do its job.

2.1 Defining Parameters and Arguments

A parameter is a special variable listed in the subprogram definition (the header). It acts as a placeholder for the data that will be passed in.
An argument is the actual data value that is passed into the subprogram when it is called (when you use it).

Analogy: Ordering Coffee

The coffee machine's design says: "I need (1) Type of Drink and (2) Size."

• Type of Drink and Size are the Parameters.
• When you order, you pass the Arguments: "Latte" and "Large".

2.2 The Importance of Parameters

Parameters make subprograms flexible. A subprogram to calculate tax isn't useful if it can only calculate tax on $100. It needs a parameter so you can tell it to calculate tax on $50, $200, or $1,000,000.

Example (Using Parameters in a Function):

1. Definition (Parameters are defined):
FUNCTION Multiply(Num1, Num2)
Result = Num1 * Num2
RETURN Result
END FUNCTION

2. Calling the function (Arguments are passed):
Total = Multiply(5, 10) // The arguments 5 and 10 are passed to Num1 and Num2
OUTPUT Total // Output is 50

---

3. Variable Scope: Local vs. Global

Variable Scope defines where in your program a variable can be accessed, read, or changed. This is critical for preventing accidental data corruption.

3.1 Global Variables

A Global Variable is declared in the main part of the program (outside of any subprogram).

• Visibility: A global variable can be accessed, read, and changed by any part of the program, including all procedures and functions.
• Lifespan: It exists from the moment the program starts until it finishes.

Analogy: The Office Calendar

A global variable is like the giant calendar hanging in the main office hallway. Everyone in the building (every function/procedure) can see it and write on it.

3.2 Local Variables

A Local Variable is declared or created inside a specific subprogram (a function or procedure).

• Visibility: It can only be accessed, read, or changed within the subprogram where it was created.
• Lifespan: It exists only for the duration that the subprogram is running. Once the subprogram ends, the local variable is destroyed (forgotten by the system).

Analogy: Your Private Notepad

A local variable is like a private notepad on your desk. Only you (that specific subprogram) can see or change the notes. When you finish your task and leave your desk, those notes are ignored by everyone else.

3.3 The Rule of Good Practice

Don't worry if this seems tricky at first! The key concept is safety.
We prefer using Local Variables and Parameters whenever possible.
Why? If a procedure accidentally changes a global variable, it could break another part of the program without warning. Local variables keep data isolated and safe.

Quick Review: Scope Comparison

• Global Variable: Declared outside; visible everywhere; risky to modify.
• Local Variable: Declared inside; visible only in the subprogram; safer and cleaner.