Course contentsShow
← Software Engineering
Lesson 326 of 1,9339. Behavioral Design PatternsFree lesson

Refactoring Toward and Away from Patterns

Learning to introduce patterns only when pain points emerge and remove them when they add no value.

Refactoring Toward and Away from Patterns

What you'll learn: How to introduce design patterns when pain points emerge and remove them when they no longer provide value.

The Two-Way Street

Design patterns aren't permanent fixtures—they're tools you add when needed and remove when they're not. Think of patterns like scaffolding on a building: essential during construction, but you take it down when the work is done. The key skill is recognizing when to move toward a pattern and when to strip one away.

Refactoring Toward Patterns

You start with simple, direct code. As requirements evolve, you notice pain points:

  • Hard to extend: Adding new behavior requires modifying existing code everywhere → Consider Strategy or State
  • Complex object creation: Constructors with 10 parameters → Consider Builder
  • Tight coupling: Classes know too much about each other → Consider Mediator or Observer
  • Conditional explosions: Giant if-else chains → Consider State or Strategy

The pattern emerges from the need, not the other way around.

Refactoring Away from Patterns

Sometimes codebases accumulate patterns that no longer serve a purpose:

  • A Strategy pattern with only one implementation
  • An Observer with a single observer that never changes
  • A Factory that creates only one type of object
  • A Command pattern for operations that never need undo

When a pattern adds layers without solving real problems, simplify. Inline the abstraction. Return to direct code. This isn't failure—it's good design hygiene.

The Discipline

Don't apply patterns preemptively "just in case." Wait for the actual pain. Conversely, don't cling to patterns out of pride. If requirements simplify, let your code follow suit.

Key Takeaway: Patterns are bidirectional refactorings—introduce them when complexity demands structure, remove them when simplicity wins. Good design evolves with your actual needs, not imagined futures.