Why are static variables considered evil?

java

static-variables

design-patterns

object-oriented

byAlex Kataev·Aug 7, 2024

The evil reputation of static variables comes from their global reach and persistent lifespan, which result in a messy mutable shared state that's hard to debug and maintain. On the other hand, instance variables or immutable static finals promote clean, testable, and maintainable code.

Example avoiding static evilishness:

public class Calculator {
    // No need for static, I'm amplifying your numbers in a very personal way
    private final int multiplier;

    // Initiating calculator with an elegant multiplier
    public Calculator(int multiplier) {
        this.multiplier = multiplier;
    }

    // Time for some multiplication magic 💫
    public int multiply(int input) {
        // Rumour has it, this might multiply your happiness too 😄
        return input * multiplier;
    }
}

The problem with static variables

Static variables vs Modularity

Static variables, since they have a global scope, work against modularity in software design, a principle of creating isolated, reusable code modules. Every static reference tightens coupling, leading to wider dependencies, making change management tricky and error-prone especially in larger systems.

Feeling static shocks during testing

Global access however results in tests unexpectedly interfering with each other, with results fluctuating depending on test execution order. To ensure reliability and predictability, each test execution will require resetting the static state, thus complicating test setups.

Static vs OO spirits

Static variables don’t gel well with object-oriented principles. Since statics can’t be controlled at the instance level, OO principles like inheritance and polymorphism are out of reach. This also means controlling the lifecycle of instances becomes tougher.

Thread carefully with mutable statics

Mutating static variables in a multithreaded environment can lead to race conditions and data problems, making it a hotbed for threading bug introduction. Without careful synchronisation, diagnosing and fixing such issues can be notoriously difficult.

Static's false halo of simplicity

Statics, at first glance, might appear to offer simplicity. However, this simple allure can easily lead developers down the rabbit hole of overuse, and the resulting code turns quite complex, largely due to the unpredictable side effects and the challenges in managing global states.

The exceptions and whereabouts of statics

Immutable static finals: The calmer side of statics

Immutable static finals used for constant values are a safe harbor in the sea of statics, as they don't suffer from the issues tied to mutability. They help maintain a single source of truth for such constants across the app.

Static excelling in utility and framework classes

Statics aptly fit into utility classes or frameworks that manage behavior needing no stateful objects. E.g., Math.PI is a good example of a well-placed static field.

Indirect globals: A wolf in sheep's clothing

In attempts to purge statics, be wary of potential indirect globals that might sneak in through methods reliant on singleton patterns or poorly used dependency injection containers, which could cloak global effects under complexity.

Designing and architecting systems: Points to ponder

Design patterns vs reliance on static variables

When wrestling with unique-instance requirements, reach for design patterns, such as the Singleton pattern, rather than leaning on static variables. Ensuring control and reasoning about the single-instance access is key to good design.

Use cases where static variables may shine

In rare cases, like building a centralized logging mechanism, static variables might be the best pick. But even then, their use should be minimal and well-justified.

Alternatives to static variables

Modern Java frameworks and design patterns provide alternatives to static variables. For example, dependency injection can provide the necessary context to objects rather than using statics. Always do a cost-benefit analysis prior to opting for a static solution.