DRY Refactoring

Process

1. Identify - Exact copies, similar patterns, parallel hierarchies, naming patterns (data1/data2, handleXClick)
2. Analyze - Coupling, cohesion, frequency (Rule of Three: wait for 3+ occurrences), volatility
3. Refactor - Choose technique below, extract incrementally, test after each step

Techniques

Extract Function - Same logic in multiple places

getFullName(user: User) => `${user.firstName} ${user.lastName}`

Extract Variable - Repeated expression

const isWorkingAge = user.age >= 18 && user.age < 65;

Parameterize - Code differs only in values

validateField(value: string, pattern: RegExp)
// Use: validateField(email, EMAIL_REGEX)

Extract Class - Related functions scattered

class UserRewards {
  calculateDiscount(user, amount) { }
  getLoyaltyPoints(user) { }
}

Polymorphism - Repeated switch/if-else

interface PaymentProcessor { process(amount: number): void }
class CreditProcessor implements PaymentProcessor { }

Strategy Pattern - Duplicated algorithm selection

const strategies = { date: byDate, name: byName };
items.sort(strategies[sortType] ?? byPriority);

Pull Up Method - Identical methods in subclasses

class BaseUser { getDisplayName() { } }
class AdminUser extends BaseUser { }

Detection

Code Smells: Look for numbered variables (data1, data2), parallel function names (handleXClick), near-identical code differing only in constants, repeated validation/error handling, parallel class structures, large switches in multiple places, repeated null checks, magic numbers

Rule of Three: Wait for 3+ occurrences before abstracting

When NOT to DRY

• Coincidental similarity - Avoid abstracting different domains/business rules that happen to look alike (will diverge)
• Premature abstraction - Wait until pattern is clear; early abstraction often guesses wrong
• Single use - Skip abstraction when code appears 1-2 times and is unlikely to grow
• Test clarity - Prefer readable test setup over DRY
• Over-engineering - Avoid abstracting every 2-3 line similarity

Patterns

• Configuration over code - Use data structures to eliminate conditionals
• Template Method - Define skeleton in base, vary steps in subclasses
• Dependency Injection - Parameterize dependencies to reduce coupling
• Builder - Construct complex objects incrementally

Best Practices

• Refactor only after tests pass (green)
• Apply one refactoring at a time
• Commit changes frequently
• Name abstractions for intent, not implementation
• Consider performance impact of abstractions
• Review abstractions with team before finalizing