Subroutines: Purpose, Structure, and Worked Examples

A subroutine is a reusable block of code that can be invoked from multiple places in a program. The key idea is separation of concerns: you write the “task logic” once, then call it whenever needed, instead of duplicating code.

Common subroutine-related concepts you will see across languages:

• procedure
• function
• parameter passing
• call stack

A typical subroutine has:

1. A signature (name, parameters, and whether it returns a value),
2. A body (the statements that implement the task),
3. A call site (where the subroutine is invoked).

Why subroutines matter

Subroutines improve programs by:

• Reducing repetition via code reuse,
• Improving maintainability (fix one place),
• Clarifying structure by isolating responsibilities,
• Supporting testing of individual components.

The runtime behavior of calls can be visualized as:

Important: Different languages use slightly different terms (e.g., “function” vs “procedure”), but the underlying purpose—reusable named execution—is the same.

Example 1: Subroutine that returns a value (factorial)

Below is a factorial example. The subroutine computes $n!$ by multiplying integers from $1$ to $n$.

Factorial definition:

Python example

1def factorial(n):
2    # subroutine: takes input n and returns n!
3    result = 1
4    for k in range(2, n + 1):
5        result *= k
6    return result
7
8# call sites:
9a = factorial(5)   # 120
10b = factorial(7)   # 5040

What to notice:

• factorial is the function subroutine.
• It uses a parameter n.
• It returns a value with return.
• The main program can call it multiple times with different inputs (code reuse).

Complexity intuition

For factorial (iterative loop), the subroutine performs a number of multiplications proportional to $n$:

(assuming arithmetic operations are treated as constant-cost for the purpose of the loop-count analysis).

Example 2: Subroutine that performs an action (printing primes)

Some subroutines are procedures: they do work but may not return a computed value.

Python example: print primes up to $N$

1def is_prime(x):
2    if x < 2:
3        return False
4    for d in range(2, x):
5        if x % d == 0:
6            return False
7    return True
8
9def print_primes_up_to(n):
10    # procedure-style: prints results; can be adapted for return
11    for x in range(2, n + 1):
12        if is_prime(x):
13            print(x)
14
15print_primes_up_to(10)
16# Output: 2 3 5 7

What to notice:

• print_primes_up_to is a subroutine that acts via side effects (printing).
• is_prime is another subroutine used inside it (composition).
• This illustrates how subroutines can be nested and reused.

Example 3: C-style subroutines (declaration vs definition)

In C, a function is typically declared (prototype) and defined (implementation). The prototype communicates the interface (parameters and return type) to the compiler before use.

Conceptual C structure:

• Prototype: tells the compiler the signature,
• Definition: contains the executable statements.

Illustrative C example

1#include <stdio.h>
2
3int add(int a, int b);  // prototype (declaration)
4
5int add(int a, int b) {  // definition
6    return a + b;
7}
8
9int main() {
10    int s = add(2, 3);   // call site
11    printf("%d\n", s);
12    return 0;
13}

This demonstrates:

• How a subroutine is invoked by add(2, 3),
• How arguments map to parameters (a, b),
• How the return value becomes s.