DRY Principle

DRY Principle: Don’t Repeat Yourself

The DRY principle (Don’t Repeat Yourself) is one of the most fundamental principles in software development. The DRY principle states that every piece of knowledge must have a single, unambiguous representation within a system. Understanding the DRY principle is essential for writing maintainable, clean code.

Simple Analogy

Think of a recipe book:

• If you write the same recipe in multiple places, you have to update it everywhere when you change it
• If you write it once and reference it, you only update it in one place
• Much easier to maintain!

The DRY Principle does the same for code.

Why DRY Principle?

DRY Principle helps you:

• Reduce duplication - Write code once, use it everywhere
• Easier maintenance - Change code in one place
• Consistency - Same logic behaves the same everywhere
• Less bugs - Fix bugs once, not in multiple places
• Better readability - Less code to read and understand

Visual: DRY Principle Concept

What Happens If We Don’t Follow DRY?

Without DRY Principle, you might:

• Duplicate code - Same logic repeated in multiple places
• Inconsistent behavior - Same logic implemented differently
• Maintenance nightmare - Need to update code in many places
• More bugs - Fix bugs in multiple places, easy to miss some
• Harder to test - Test same logic multiple times

Common Problem

Without DRY, changing business logic means finding and updating code in multiple places. With DRY, you change it once and it’s updated everywhere!

Visual: The Duplication Problem

---

Simple Example: User Validation

Let’s see a simple example showing the problem and solution:

The Problem: Code Duplication

Visual: Code Duplication Flow

The Solution: DRY Principle

Visual: DRY Solution Flow

Key Benefits

✅ Single source of truth - Logic defined once
✅ Easier maintenance - Change once, affects all uses
✅ Consistency - Same behavior everywhere
✅ Less bugs - Fix once, not in multiple places
✅ Easier testing - Test logic once

---

Real-World Example: Database Connection

Here’s a more realistic example showing DRY in action:

---

When to Apply DRY?

Apply DRY Principle when:

✅ Same logic appears multiple times - Extract to function/class
✅ Business rules are repeated - Centralize in one place
✅ Configuration values duplicated - Use constants/config
✅ Similar code patterns - Create reusable abstractions
✅ Data structures repeated - Define once, reuse

Visual: When to Apply DRY

When NOT to Over-Apply DRY?

Don’t over-apply DRY when:

❌ Code is similar but different - Don’t force abstraction
❌ Premature abstraction - Wait until you see actual duplication
❌ Over-engineering - Simple duplication might be fine
❌ Performance critical - Sometimes duplication is faster

Balance is Key

Don’t over-abstract! DRY is about eliminating real duplication, not forcing everything into abstractions. Sometimes a little duplication is better than over-engineering!

---

Key Takeaways

• DRY Principle = Don’t Repeat Yourself
• Single source of truth - Every piece of knowledge in one place
• Easier maintenance - Change once, affects all uses
• Consistency - Same behavior everywhere
• Balance - Don’t over-abstract, eliminate real duplication

Remember: DRY is about eliminating real duplication, not creating unnecessary abstractions. Use it wisely! 🎯