Don't Repeat Yourself

Introduction

In software development, one of the simplest yet most powerful ideas you can follow is:

“Don't Repeat Yourself”

The DRY Principle isn't just about saving time or typing less – it's about writing clean, maintainable, and reliable code that evolves gracefully as the system grows.

Let's explore what its really mean, why it matters, and how to apply it effectively.

What is the DRY Principle?

The DRY Principle (Don't Repeat Yourself) was first introduced in the book The Pragmatic Programmer by Andy Hunt and Dave Thomas.

They defined it as:

“Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.”

In Simple terms – don't duplicate logic, functionality, or data.

Whenever you find the same code or concept being repeated across multiple places, it's usually a sing that something needs to be refactored or abstracted.

Why is Repetition a Problem?

At first glance, copying and pasting a few lines of code may seem harmless.

But over time, repetition cause serious issues:

1. Harder Maintenance
   1. If the logic changes, you have to update it in every place it appears – increasing the risk of missing one.
2. Inconsistent Behavior
   1. Multiple copies can become slightly different over time, leading to inconsistent behavior or unexpected bugs.
3. Reduced Reliability
   1. Repeated code clutters the codebase, making it harder to understand what's actually unique or important.
4. Increased Technical Debt
   1. Duplication adds hidden complexity – more testing, more updates, more rooms for errors.

Applying the DRY Principle

Applying DRY doesn't mean you must never repeat a single line of code.

It means identifying duplicated knowledge and consolidating it into a single source of truth.

Here are practical ways to apply DRY in the codebase

1 Extract Reusable Functions or Methods

When you notice repeated logic, extract it into a function or utility method that can be reused.

Before:

int total1 = price1 + (price1 * taxRate / 100);
int total2 = price2 + (price2 * taxRate / 100);

After:

int calculateTotal(int price, double taxRate) {
    return price + (price * taxRate / 100);
}

int total1 = calculateTotal(price1, taxRate);
int total2 = calculateTotal(price2, taxRate);

2 Use Constants for Repeated Values

Avoid hardcoding the same values in multiple places.

Before:

if (user.age > 18) {
    // Adult
}
if (driver.age > 18) {
    // Eligible
}

After:

const int MIN_AGE = 18;
if (user.age > MIN_AGE) { ... }
if (driver.age > MIN_AGE) { ... }

One update changes all dependent logic – no search-and-replace chaos.

3 Reuse Components and Classes

In object-oriented design, identify shared responsibilities and move them into base classes or utility components.

Example:

If multiple classes need logging, instead of copying the same code, use a shared Logger class.

class Logger {
public:
    static void log(std::string message) {
        std::cout << "[LOG]: " << message << std::endl;
    }
};

Then reuse:

class Logger {
public:
    static void log(std::string message) {
        std::cout << "[LOG]: " << message << std::endl;
    }
};

4 Centralize Configuration and Constants

Instead of repeating file paths, URLs, or settings, place them in a configuration file or environment variable.

Why?

When a URL or parameter changes, you only need to update it once – not in 20 different files.

5 Reuse Templates and Layouts

In web or frontend development, use common templates or partials for shared layout (like headers, navbars, or footers). This keep UI consistent and easier to modify later.

Dry Beyond Code

The DRY principle isn't limited to code – it applies to:

• Documentation (avoid duplicating instructions)
• Database schema (avoid redundant fields)
• Business rules (centralize logic)

Whenever a single concept exists in multiple forms – DRY helps bring it back to one source of truth.