DRY (Don't Repeat Yourself) Overview
Every piece of knowledge must have a single, unambiguous representation in the system.
If you find yourself writing the same logic twice, extract it. Duplication is a bug waiting to happen.
When to Use Writing code similar to existing code Copy-pasting and modifying Making the same change in multiple files Validation logic repeated across forms Same calculations in different places The Iron Rule NEVER duplicate logic. Extract and reuse.
No exceptions:
Not for "it's faster to copy" Not for "they're slightly different" Not for "I'll refactor later" Not for "it's just a few lines" Detection: The Copy-Paste Smell
If you're about to copy code and modify it, STOP:
// ❌ VIOLATION: Duplicated validation function validateRegistrationEmail(email: string): boolean { return /^[^\s@]+@[^\s@]+.[^\s@]+$/.test(email); }
function validateProfileEmail(email: string): boolean { return /^[^\s@]+@[^\s@]+.[^\s@]+$/.test(email); // Same logic! }
// ✅ CORRECT: Single source of truth function validateEmail(email: string): boolean { return /^[^\s@]+@[^\s@]+.[^\s@]+$/.test(email); }
// Reuse everywhere const isValidRegistration = validateEmail(regEmail); const isValidProfile = validateEmail(profileEmail);
Detection: The "Change in Multiple Places" Test
If fixing a bug requires changing multiple locations, you have duplication:
// ❌ Bug in tax calculation requires changes in 3 files // cart.ts: const tax = price * 0.08; // checkout.ts: const tax = price * 0.08; // invoice.ts: const tax = price * 0.08;
// ✅ Single source of truth // tax.ts: export const calculateTax = (price: number) => price * TAX_RATE;
The Correct Pattern: Extract and Parameterize
When code is "almost the same", extract the common part and parameterize the differences:
// ❌ VIOLATION: Similar functions with minor differences
function formatUserName(user: User): string {
return ${user.firstName} ${user.lastName};
}
function formatAdminName(admin: Admin): string {
return ${admin.firstName} ${admin.lastName} (Admin);
}
// ✅ CORRECT: Parameterized
function formatName(person: { firstName: string; lastName: string }, suffix?: string): string {
const name = ${person.firstName} ${person.lastName};
return suffix ? ${name} (${suffix}) : name;
}
Pressure Resistance Protocol 1. "It's Faster to Copy"
Pressure: "I'll just copy this and modify it"
Response: Copying creates two places to maintain. Bugs will diverge.
Action: Extract shared logic first, then use it in both places.
- "They're Slightly Different"
Pressure: "The functions are almost the same but not quite"
Response: "Almost the same" = extract common part, parameterize differences.
Action: Identify what's shared, extract it, make differences parameters.
- "It's Just a Few Lines"
Pressure: "It's only 3 lines, not worth extracting"
Response: 3 lines duplicated 5 times = 15 lines to maintain. Bugs multiply.
Action: Extract even small duplications. Name them well.
- "I'll Refactor Later"
Pressure: "Ship now, DRY it up later"
Response: You won't. Duplication spreads. DRY now takes 2 minutes.
Action: Extract before committing the duplication.
Red Flags - STOP and Reconsider
If you notice ANY of these, you're about to violate DRY:
Ctrl+C / Ctrl+V in your workflow "This is similar to that other function" Same regex/validation in multiple places Identical error handling patterns repeated Same data transformation logic duplicated Constants defined in multiple files
All of these mean: Extract to a shared location.
Types of Duplication Type Example Solution Code Same function body twice Extract function Logic Same algorithm, different names Extract and parameterize Data Same constant in multiple files Centralize constants Structure Same class shape repeated Extract interface/base Knowledge Business rule in multiple places Single source of truth Quick Reference Symptom Action Copy-pasting code Extract shared function Same validation twice Create validator module Same constant in files Create constants file Similar functions Extract + parameterize Bug fix needs multiple changes Consolidate to one place Common Rationalizations (All Invalid) Excuse Reality "It's faster to copy" It's slower to maintain duplicates. "They're slightly different" Extract common, parameterize differences. "Just a few lines" Few lines × many places = many bugs. "I'll refactor later" You won't. Extract now. "Different contexts" Same logic = same code, regardless of context. "More readable as copies" Named, extracted functions are more readable. The Bottom Line
One piece of knowledge. One place in code.
When writing similar code: stop, find the existing code, extract if needed, reuse. Duplication is the root of maintenance nightmares.