Side effects and external state

refactoring

Last reviewed

February 6, 2025

Last modified

March 25, 2025

Side effects occur when a function modifies external state or interacts with the outside world beyond simply returning a value. This makes code less predictable, harder to test, and more difficult to debug.

Symptoms

Unexpected changes to the global state
Non-deterministic behavior
Hidden dependencies

Tip

Pure functions are deterministic (always return the same output for the same input) and have no side-effects.

Instead, non-pure functions often:

Modify global variables or shared state, leading to unintended behavior.
Change input parameters (mutating function arguments).
Perform I/O operations like reading from or writing to files, databases, or APIs.
Generate random numbers, making them non-deterministic.
Depend on external state, meaning results may change due to external factors.

Example - Function with side effects

# Modifies global state (side effect)
data = []

def add_item(item):
    data.append(item)  # Changes an external variable

add_item("A")
print(data)  # ['A'] - Output depends on previous calls

Solutions

1. Separate pure and non-pure functions

Keep your computational logic (pure) separate from side-effect operations (non-pure).

def process_data(data):  # Pure function: no external state modification
    return [x**2 for x in data]

def save_to_file(filename, data):  # Non-pure: writes to a file
    with open(filename, "w") as f:
        f.write("\n".join(map(str, data)))

# Usage
numbers = [1, 2, 3]
processed = process_data(numbers)
save_to_file("output.txt", processed)

2. Avoid mutating global variables

Use function parameters and return values instead of modifying external variables.

def add_item(data, item):
    return data + [item]  # Returns a new list instead of modifying global state

data = []
data = add_item(data, "A")  # Safe: no side effects

Key takeaways

Ensure that each function or module has a single responsibility.
Break down complex functions into smaller, focused functions that perform specific tasks.
Isolate non-pure functions with side effects from pure functions.