Photo by khampha phimmachak on Unsplash

Your programming assistant #6: Benefits of Functions and Procedures

In modern programming languages, functions and procedures concepts overlap a lot, and it is fair to say that nowadays the distinction is merely conceptual. But it is also fair to say that understanding such distinction still matters in order to grasp the full potential of algorithms.

Function

• Definition: A function is a reusable block of code designed to perform a specific task and return a value.
• Key Feature: Always has a return value, even if it’s null or void in some contexts.
• Example Use Case: Performing a calculation and returning the result.
• Example (Python):

def add(a, b):
    return a + b

result = add(3, 5)  # result = 8

The fact that the function returns a value allows us to use that value to make logic elsewhere. It makes it simple to handle variables that require complex logic to have their values determined, isolating the calculations and allowing a cleaner code.

Procedure

• Definition: A procedure is a reusable block of code that performs a specific task but does not return a value.
• Key Feature: Primarily used for side effects (e.g., modifying variables, printing output).
• Terminology: In many modern languages, “procedures” are implemented as functions with no explicit return value (or with a void return type).
• Example Use Case: Printing a message or updating a database.
• Example (Javascript):

function greet(name) {
    console.log(`Hello, ${name}!`);
}

// Calling the procedure
greet("Alice"); // Outputs: Hello, Alice!

The fact that the procedure doesn't return a value implies that it will perform a side-effect, rather than calculate a value to be used subsequently in the code. And sometimes we need to use and handle side-effects, so understanding what a procedure is, even if it's meaning is so close to what a function is, allows us to write a better code in which the separation of those concerns is clear.

Advantages of Using Functions

1. Return Values: Functions compute and return values, allowing their results to be used in other parts of the program. This enables more dynamic and modular code.
2. Modularity: Functions break down complex problems into smaller, manageable parts. Each function can handle a specific task, making the program easier to understand and debug.
3. Reusability: Once defined, functions can be reused multiple times in different parts of a program or even in other programs, saving time and effort.
4. Composability: Functions can be composed to work together. For example, the output of one function can serve as the input for another.
5. Improved Testing: Functions can be tested individually to ensure correctness, simplifying the debugging process.
6. Flexibility: They can return results based on dynamic input, making them versatile tools in programming.

Advantages of Using Procedures

1. Performing Side Effects: Procedures are ideal for tasks that involve actions like printing to the console, writing to a file, or updating a database.
2. Simplicity: Without a need to return values, procedures often have simpler logic and are easier to write for straightforward tasks.
3. Modularity: Like functions, procedures can divide a program into smaller parts focused on specific tasks.
4. Reusability: Procedures can also be reused wherever their specific actions are needed, contributing to less redundancy.
5. Improved Readability: Procedures help document the intent of side-effect operations, making the code easier to follow.

Combining Functions and Procedures

In many applications, functions and procedures work together:

• Functions compute values.
• Procedures handle actions or side effects like displaying results or saving data.
• Example (Ruby):

# Function: Computes and returns the sum of two numbers
def add(a, b)
  a + b
end

# Procedure: Logs the result to the console
def log_result(result)
  puts "The result is: #{result}"
end

# Using the function and procedure together
sum = add(3, 7)       # Calls the function to compute the sum
log_result(sum)       # Calls the procedure to log the result

Output:

The result is: 10

Explanation

1. Function (add): Takes two arguments, a and b and returns their sum.
2. Procedure (log_result): Takes a single argument, result and outputs a formatted string to the console.
3. Usage: The result of the add function is stored in the sum variable. The log_result procedure uses sum to log the result.

This approach keeps the computation logic separate from the display logic, adhering to principles of modular programming.