Subroutines in Pseudocode: Functions and Procedures

Subroutines are blocks of code designed to perform a specific task. They help make programs more modular, reusable, and easier to maintain. Subroutines come in two types: functions and procedures. While both serve the purpose of organizing code, the key difference is that functions return a value, whereas procedures do not.

This guide will break down subroutines step-by-step, starting from simple examples and progressing to more advanced scenarios, including nested subroutines and parameter passing. We’ll also look at how to declare and call subroutines separately for clarity.

1. Introduction to Subroutines

Subroutines help avoid repetition in code by allowing us to encapsulate a specific task in one place and reuse it multiple times. This makes programs easier to understand and maintain. Whenever you find yourself repeating a piece of logic, it's a good candidate for turning into a subroutine.

• Functions: Perform a task and return a result.
• Procedures: Perform a task but don’t return a value.

2. Subroutine Declaration

2.1. Declaring a Procedure

A procedure is declared using the PROCEDURE keyword. It may accept parameters, but it does not return a value.

Syntax:

Example:

In this example, the procedure GreetUser takes a name as input and outputs a greeting.

2.2. Declaring a Function

A function is declared using the FUNCTION keyword. Functions differ from procedures in that they return a value, which must be specified by the RETURN keyword.

Syntax:

Example:

Here, AddNumbers takes two integers and returns their sum.

3. Subroutine Call

3.1. Calling a Procedure

To call a procedure, use the CALL keyword followed by the procedure name and any required arguments.

Syntax:

Example:

Here, GreetUser is called with the argument "Alice", and it outputs the greeting "Hello, Alice".

3.2. Calling a Function

Unlike procedures, functions are called as part of an expression since they return a value. The CALL keyword is not used for functions.

Syntax:

Example:

In this example, AddNumbers is called with the arguments 10 and 5, and the result (15) is stored in sum.

4. Advanced Usage of Subroutines

4.1. Passing Parameters by Value and by Reference

In pseudocode, parameters can be passed in two ways:

• By Value (`BYVAL`): A copy of the argument is passed to the subroutine. Changes to the parameter inside the subroutine do not affect the original variable.
• By Reference (`BYREF`): A reference to the original variable is passed. Changes to the parameter inside the subroutine affect the original variable.

By Value (Default):

By Reference:

Calling this procedure modifies the original variable when using `BYREF`, but not when using `BYVAL`.

4.2. Nested Subroutines

Subroutines can call other subroutines within their body. This helps to break down complex tasks into smaller, manageable parts.

Example:

Here, CalculateSquare calls the Square function to compute the square of a number and then outputs the result. The function handles the calculation, while the procedure handles the output.

4.3. Using Subroutines with Arrays

Subroutines can also take arrays as parameters, allowing them to perform operations on collections of data.

Example:

In this example, PrintArray takes an array as an argument and prints each element of the array. Subroutines working with arrays are useful for sorting, searching, or performing bulk operations on data.

5. Subroutines and Recursion

Subroutines can also call themselves—this is known as recursion. Recursion is useful for tasks like calculating factorials, traversing trees, or solving puzzles (e.g., the Tower of Hanoi).

Example of a Recursive Function:

In this example, the function Factorial calls itself to calculate the factorial of a number, with the base case being when n = 1.

6. Summary: Functions vs. Procedures

Here’s a brief comparison and summary of when to use functions and procedures.

Functions:

• Purpose: Functions perform a task and return a value.
• Use When: You need to compute or derive a result that will be used in further calculations or logic.
• Example: Calculating the sum of two numbers, returning the square of a number.

Procedures:

• Purpose: Procedures perform a task but do not return a value.
• Use When: You need to perform an action (e.g., display a message, modify variables, update arrays) without needing a return value.
• Example: Printing output, modifying an array or variable by reference.

7. When to Use Each

• Use Functions when you need to return a result to be used later in your program, especially for calculations or data transformations.
• Use Procedures when you need to perform an action (like modifying variables or printing output) but do not need a return value.

8. Conclusion

Subroutines (both functions and procedures) are essential tools in programming for organizing code, promoting reusability, and making the code more modular. Functions return values, making them ideal for calculations and deriving data, while procedures are suited for performing actions without returning data. Mastering both will help you write cleaner and more efficient pseudocode!