Subroutines: Procedures and Functions

A subroutine is a named block of code that performs a specific task. Subroutines allow code to be written once and called (used) many times. Cambridge IGCSE distinguishes two types: procedures and functions.

Procedures

A procedure is a subroutine that performs a task but does NOT return a value. It may accept parameters (input values) but it outputs results through side effects (e.g., OUTPUT statements) rather than returning a value.

Defining a procedure

PROCEDURE greet(name : STRING)
    OUTPUT "Hello, " & name
ENDPROCEDURE

Calling a procedure

CALL greet("Alice")   // Outputs: Hello, Alice
CALL greet("Bob")     // Outputs: Hello, Bob

Procedure without parameters

PROCEDURE drawLine()
    OUTPUT "-------------------"
ENDPROCEDURE

CALL drawLine()

Functions

A function is a subroutine that performs a task AND returns a value to the calling code. The return type must be specified in the definition. The RETURN keyword sends the result back.

Defining a function

FUNCTION square(n : INTEGER) RETURNS INTEGER
    RETURN n * n
ENDFUNCTION

Calling a function

result ← square(5)        // result = 25
OUTPUT square(4)          // Outputs 16
OUTPUT square(3) + 1      // Outputs 10

Function with a condition

FUNCTION isEven(num : INTEGER) RETURNS BOOLEAN
    IF num MOD 2 = 0 THEN
        RETURN TRUE
    ELSE
        RETURN FALSE
    ENDIF
ENDFUNCTION

Comparing Procedures and Functions

Parameters

Parameters are values passed into a subroutine when it is called. They are listed in brackets after the subroutine name in the definition, with their data types specified.

FUNCTION add(a : INTEGER, b : INTEGER) RETURNS INTEGER
    RETURN a + b
ENDFUNCTION

OUTPUT add(3, 7)   // Outputs 10

Benefits of Using Subroutines

• Avoid code duplication — write once, call many times
• Easier to test and debug individual sections
• Easier to read and understand (meaningful names)
• Easier to maintain — change the code in one place