praetorian-inc/public-workflows/adhering-to-dry

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: 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 - Different domains/business rules that happen to look alike (will diverge)
• Premature abstraction - Pattern isn't clear yet; early abstraction often guesses wrong
• Single use - Appears 1-2 times, unlikely to grow
• Test clarity - Readable test setup beats DRY
• Over-engineering - Don't abstract every 2-3 line similarity

Patterns

• Configuration over code - Data structures eliminate conditionals
• Template Method - Base defines skeleton, subclasses vary steps
• Dependency Injection - Parameterize dependencies
• Builder - Complex object construction

Best Practices

• Refactor after green tests
• One refactoring at a time
• Commit frequently
• Name for intent not implementation
• Consider performance
• Review abstractions with team

Related Techniques

• Balance DRY against YAGNI — don't abstract speculative features before they exist.
• Balance DRY against simplicity — avoid over-engineering; the simplest version that removes the duplication wins.
• Apply DRY during the refactor step after tests are green, so changes stay safe.
• Before writing new code, search the codebase for an existing implementation to reuse rather than duplicate.