Speculative Generality

Also Known As

TL;DR

Explanation

Speculative generality is the code smell version of over-engineering: creating abstract classes with one subclass, adding unused parameters for flexibility, or writing hook points for requirements that don't exist yet. It violates YAGNI and adds cognitive overhead for every reader. Remove unused abstractions, parameters, and delegate methods that serve no current purpose — refactoring tools make re-introducing them straightforward if the need genuinely arises.

Common Misconception

Why It Matters

Common Mistakes

• Adding abstract base classes 'in case we need another implementation later' with only one concrete class.
• Plugin architectures for internal code that never needs to be pluggable.
• Configuration files for behaviour that has never varied and shows no sign of varying.
• Not applying YAGNI — the cost of adding abstraction when needed is almost always less than carrying premature abstraction.

Code Examples

// Built for flexibility nobody asked for yet
interface AbstractDataProviderFactoryInterface {
    public function create(string \$type): DataProviderInterface;
}
class ConcreteDataProviderFactory implements AbstractDataProviderFactoryInterface {
    public function create(string \$type): DataProviderInterface {
        return new DatabaseDataProvider(); // only one type ever exists
    }
}

// YAGNI — build what's needed today
class DatabaseDataProvider {
    public function getData(): array { return \$this->db->fetchAll(); }
}
// Add the interface/factory if and when a second provider materialises

References

• ↗ https://refactoring.guru/smells/speculative-generality
• ↗ https://martinfowler.com/bliki/YAGNI.html
• ↗ https://wiki.c2.com/?SpeculativeGenerality

Tags

Related Terms