Python example

def add_numbers(num1, num2):
    # This function adds two numbers and returns the result
    result = num1 + num2
    return result

# Calling the function
sum = add_numbers(5, 3)
print("Sum:", sum)  # Output: Sum: 8

C# example

public int AddNumbers(int num1, int num2)
{
    // This function adds two numbers and returns the result
    int result = num1 + num2;
    return result;
}

// Calling the function
int sum = AddNumbers(5, 3);
Console.WriteLine("Sum: " + sum);  // Output: Sum: 8

Code Organisation

Functions help break down large programs into smaller, more manageable pieces. Each function handles a specific task, making the code easier to understand and maintain.

Reusability

Once a function is defined, it can be used over and over again throughout the program. This saves time and reduces redundancy by avoiding the need to rewrite the same code.

Simplicity

Functions abstract away complex details, providing a simpler interface for other parts of the program to interact with. This makes the code easier to comprehend and speeds up development.

Modularity

By separating code into functions, developers can work on individual parts of the program independently. This promotes collaboration and allows for easier troubleshooting and debugging.

Scalability

As programs grow, functions help manage complexity by breaking down tasks into smaller, more manageable chunks. This makes it easier to extend and adapt the program as requirements change.

Built-in

These are ready-to-use functions provided by the programming language or its libraries. They help with common tasks like math operations, working with strings, or handling input/output.

// Using built-in function to get the length of a string
const text = "Hello, World!";
const length = text.length;

console.log("Length of the string:", length);

User-defined

These are functions created by programmers to perform specific tasks. They make code more organised, easier to read, and reusable.

// User-defined function to add two numbers
function add(a, b) {
    return a + b;
}

const result = add(5, 3);
console.log("Result of addition:", result);

Recursive

These functions call themselves to solve a problem by breaking it into smaller, similar subproblems. They’re handy for tasks like calculating factorials or working with recursive data structures.

// Recursive function to calculate factorial
function factorial(n) {
    if (n === 0) {
        return 1;
    } else {
        return n * factorial(n - 1);
    }
}

const result = factorial(5);
console.log("Factorial of 5:", result);

Anonymous (Lambda)

These are small, nameless functions used for short operations. They’re often used in situations where a quick function is needed, like sorting or filtering data.

// Using an anonymous function (lambda) to perform addition
const add = (x, y) => x + y;
const result = add(5, 3);

console.log("Result of addition:", result);

Value Parameters

// Copies the argument's value.
void Square(int x) {
    x = x * x;
}

// Example of Passing by Value:
int number = 10;
Square(number); // number remains 10

Reference Parameters

// Allows a function to modify the argument's value directly.
void Increment(ref int x) {
    x++;
}

// Example of Passing by Reference:
int number = 10;
Increment(ref number); // number becomes 11

Output Parameters

// Allows a function to return multiple values.
void Divide(int dividend, int divisor, out int quotient, out int remainder) {
    quotient = dividend / divisor;
    remainder = dividend % divisor;
}

// Example of Output Parameters:
int dividend = 10, divisor = 3;
int quotient, remainder;

// quotient is 3, remainder is 1
Divide(dividend, divisor, out quotient, out remainder);

Naming Conventions

• Use descriptive names for functions that clearly convey their purpose.
• Stick to the naming conventions of the language you’re using (camelCase, snake_case, etc.).
• Avoid vague or generic names like “foo” or “bar”.

Modularity

• Keep functions focused on doing one thing well.
• Break down complex tasks into smaller, reusable functions.
• Organise related functions together to make your code easier to follow.

Documentation

• Write clear and concise comments or docstrings explaining what each function does, its parameters, and return values.
• Update documentation whenever the function’s behavior changes.

Avoiding Side Effects

• Aim for functions to produce the same output for the same inputs (deterministic behavior).
• Minimise changes to external state (like global variables) within functions.
• If a function does have side effects, document them clearly.