# Modularity, Functions & Procedures ## What is Modularity? - **Modularity** is the practice of dividing complex problems into smaller, more manageable components - Each component should handle a **single, specific task** within the overall solution - These individual components are called **subroutines** (also known as modules) - Subroutines are self-contained blocks of code that execute when called - When called, a subroutine carries out its designated task and then control returns to the calling code

A **subroutine** is an independent code block designed to perform a specific task when invoked

### Benefits of Modularity - **Code reusability**: Write once, use many times throughout your program - **Organisation**: Breaks down complex logic into understandable chunks - **Maintainability**: Easier to locate and fix bugs in isolated components - **Efficiency**: Allows programmers to write clean, structured programs - **Collaboration**: Different team members can work on separate subroutines simultaneously ## Functions vs Procedures - Both **functions** and **procedures** are types of subroutines - They share many characteristics but have one crucial difference ### Key Difference | Feature | Function | Procedure | |---------|----------|-----------| | **Returns a value** | ✓ Yes | ✗ No | | **Purpose** | Calculate and return a result | Perform an action or series of actions | | **Example use** | Calculate tax on a price | Display a welcome message |

If you need a result back from your subroutine, use a **function**; if you just need something done, use a **procedure**

### Parameters - Both functions and procedures can accept **parameters** - **Parameters** are pieces of information passed into the subroutine - These allow the subroutine to work with different data each time it's called - Parameters enable flexibility and reusability ## Best Practices ### Naming Conventions - Choose **descriptive and meaningful** names that clearly indicate purpose - Examples: - Good: `calculateTotalPrice()`, `displayUserDetails()` - Poor: `doStuff()`, `x()` ### Parameter Naming - Use clear, meaningful names for parameters to improve readability - Example: `calculateArea(length, width)` rather than `calculateArea(a, b)` ### Keep Functions Focused - Aim for subroutines that are **short and focused** - Each should accomplish one specific task - If a subroutine does too much, consider breaking it into smaller subroutines ### Return Values - **Functions** must have explicit return statements with meaningful values - **Procedures** should not include return statements (or return nothing) ## Functions ### Syntax - A function is declared using the `function` keyword - Must specify the function name and any parameters - Must include a `return` statement with a value ```text function functionName(parameter1, parameter2) // Code block to perform the task // Return value endfunction ``` ### Pseudocode Example - In this example, two values are passed as parameters (`x` and `y`) - The function adds them together and returns the sum ```text function addTwoNumbers(x, y) total = x + y return total endfunction result = addTwoNumbers(15, 27) print(result) ``` **Output**: `42` ### Python Example ```python def multiply_values(a, b): return a * b answer = multiply_values(8, 7) print(answer) ``` **Output**: `56`

In Python, use `def` to define functions, followed by parentheses containing any parameters

### Java Example ```java public class Main { public static void main(String[] args) { int answer = multiplyValues(8, 7); System.out.println(answer); } public static int multiplyValues(int a, int b) { return a * b; } } ``` **Output**: `56` ### Function Call Flow 1. The main program reaches a function call 2. Control transfers to the function 3. Parameters are passed to the function 4. Function executes its code block 5. Function returns a value 6. The returned value is used in the calling statement 7. Control returns to the main program ### Example: Square Root Function **Pseudocode**: ```text function calculateSquareRoot(number) return number ^ 0.5 endfunction value = 64 squareRoot = calculateSquareRoot(value) print("The square root of " + value + " is " + squareRoot) ``` **Output**: `The square root of 64 is 8` **Python**: ```python def calculate_square_root(number): return number ** 0.5 value = 64 square_root = calculate_square_root(value) print(f"The square root of {value} is {square_root}") ``` **Java**: ```java public static double calculateSquareRoot(double number) { return Math.pow(number, 0.5); } public static void main(String[] args) { double value = 64; double squareRoot = calculateSquareRoot(value); System.out.println("The square root of " + value + " is " + squareRoot); } ``` ## Procedures ### What is a Procedure? - A procedure is similar to a function but **does not return a value** - Instead, it performs a sequence of operations - These operations could be anything the programmer needs executed - Essentially a function without a return statement (or returning nothing) ### Syntax ```text procedure procedureName(parameter1, parameter2) // Code block to perform actions // No return statement or return with no value endprocedure ``` ### Pseudocode Example - Two values are passed as parameters (`x` and `y`) - The procedure adds them together and **prints** the result - Since it's a procedure, the result **cannot be returned** ```text procedure addAndDisplay(x, y) sum = x + y print(sum) endprocedure addAndDisplay(23, 19) ``` **Output**: `42` ### Python Example ```python def display_greeting(first_name, last_name): full_name = first_name + " " + last_name print("Welcome, " + full_name + "!") display_greeting("Sarah", "Johnson") ``` **Output**: `Welcome, Sarah Johnson!`

Procedures perform actions but don't return values, so you can't assign their result to a variable

### Java Example ```java public static void displayGreeting(String firstName, String lastName) { String fullName = firstName + " " + lastName; System.out.println("Welcome, " + fullName + "!"); } public static void main(String[] args) { displayGreeting("Sarah", "Johnson"); } ``` **Output**: `Welcome, Sarah Johnson!` ### Example: Temperature Converter Procedure **Pseudocode**: ```text procedure convertAndDisplay(celsius) fahrenheit = (celsius * 9/5) + 32 print(celsius + "°C is equal to " + fahrenheit + "°F") endprocedure convertAndDisplay(25) convertAndDisplay(0) convertAndDisplay(100) ``` **Output**: ```text 25°C is equal to 77°F 0°C is equal to 32°F 100°C is equal to 212°F ``` **Python**: ```python def convert_and_display(celsius): fahrenheit = (celsius * 9/5) + 32 print(f"{celsius}°C is equal to {fahrenheit}°F") convert_and_display(25) convert_and_display(0) convert_and_display(100) ``` **Java**: ```java public static void convertAndDisplay(double celsius) { double fahrenheit = (celsius * 9.0/5.0) + 32; System.out.println(celsius + "°C is equal to " + fahrenheit + "°F"); } public static void main(String[] args) { convertAndDisplay(25); convertAndDisplay(0); convertAndDisplay(100); } ``` ## Comparison Table | Aspect | Function | Procedure | |--------|----------|-----------| | **Returns value** | Yes, always | No | | **Return statement** | Must have explicit return with value | No return statement or empty return | | **Can be used in expressions** | Yes (e.g., `x = myFunction(5)`) | No | | **Can be called alone** | Yes, but returned value is lost | Yes, typical usage | | **Common uses** | Calculations, data transformations | Displaying output, updating states | | **Example** | `total = calculateSum(a, b)` | `displayWelcome(userName)` | ## Practical Examples ### Function Example: Check Password Strength **Pseudocode**: ```text function checkPasswordStrength(password) if password.length < 8 then return "Weak" elseif password.length < 12 then return "Medium" else return "Strong" endif endfunction userPassword = input("Enter your password: ") strength = checkPasswordStrength(userPassword) print("Your password strength is: " + strength) ``` ### Procedure Example: Draw Border **Pseudocode**: ```text procedure drawBorder(character, width) for i = 1 to width print(character) next i print("\n") endprocedure drawBorder("*", 40) print("Welcome to the System") drawBorder("*", 40) ``` **Output**: ```text **************************************** Welcome to the System **************************************** ``` ### Combined Example: Student Grades **Python**: ```python def calculate_average(marks): total = sum(marks) average = total / len(marks) return average def display_report(student_name, average): print(f"Student: {student_name}") print(f"Average Mark: {average:.1f}") if average >= 70: print("Grade: A") elif average >= 60: print("Grade: B") elif average >= 50: print("Grade: C") else: print("Grade: F") print("-" * 30) # Main program student_marks = [78, 65, 82, 91, 73] avg = calculate_average(student_marks) display_report("Emma Watson", avg) ``` **Output**: ```text Student: Emma Watson Average Mark: 77.8 Grade: A ------------------------------ ```

Notice how `calculate_average()` returns a value (function) while `display_report()` performs output actions (procedure)

## Why Use Subroutines? ### Problem: Calculate area of multiple rectangles **Without subroutines** (repetitive): ```text length1 = 5 width1 = 3 area1 = length1 * width1 print(area1) length2 = 8 width2 = 4 area2 = length2 * width2 print(area2) length3 = 12 width3 = 6 area3 = length3 * width3 print(area3) ``` **With a function** (efficient): ```text function calculateRectangleArea(length, width) return length * width endfunction print(calculateRectangleArea(5, 3)) print(calculateRectangleArea(8, 4)) print(calculateRectangleArea(12, 6)) ``` ### Benefits Demonstrated - **Less code**: Three lines instead of twelve - **Easier to maintain**: Change calculation logic in one place - **Fewer errors**: No risk of typing mistake in repeated code - **More readable**: Clear what the code does