DRY (Don't Repeat Yourself) in LLD - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Why is DRY important in system design?

Imagine you are designing a system with multiple modules that share similar logic. Why should you apply the DRY principle?

A To reduce code duplication and make maintenance easier

B To increase the number of lines of code for clarity

C To make each module completely independent with no shared code

D To add more comments explaining repeated code

💡 Hint

Think about how repeating the same code affects fixing bugs or adding features.

DRY helps avoid repeating code so that changes need to be made in only one place, reducing errors and saving time.

❓ Architecture

intermediate

Which design best follows DRY for shared validation logic?

You have multiple services that need to validate user input in the same way. Which architecture approach best follows DRY?

A Each service implements its own validation code separately

B Copy validation code from one service to others when needed

C Create a shared validation library used by all services

D Skip validation to avoid repeating code

💡 Hint

Think about how to reuse code without copying it.

A shared library centralizes validation logic, so updates happen once and apply everywhere, following DRY.

❓ scaling

advanced

How does DRY help when scaling a system?

When a system grows and new features are added, how does following DRY help with scaling?

A It forces rewriting all code for each new feature

B It reduces the effort to update shared logic, making scaling faster and less error-prone

C It increases code duplication, which helps isolate features

D It makes the system slower by adding extra layers

💡 Hint

Think about how shared code affects adding or changing features.

DRY reduces duplicated code, so changes to shared logic only need to be done once, easing scaling.

❓ tradeoff

advanced

What is a potential downside of applying DRY too aggressively?

Applying DRY is good, but what problem can happen if you try to share code too much?

A It always improves performance without any downside

B It causes code duplication to increase

C It makes the system impossible to test

D It can create tight coupling making changes risky and complex

💡 Hint

Think about what happens if many parts depend on the same code.

Over-sharing code can cause tight coupling, so a small change affects many parts, increasing risk.

❓ component

expert

In a microservices system, how to apply DRY for common logging?

You have many microservices that need consistent logging. Which approach best applies DRY?

A Use a centralized logging service or library shared by all microservices

B Implement logging code separately in each microservice

C Copy logging code from one microservice to others when needed

D Avoid logging to reduce code repetition

💡 Hint

Think about how to reuse logging logic without duplication across services.

A centralized logging service or shared library ensures consistent logging and avoids code duplication, following DRY.

Practice

1. What is the main goal of the DRY principle in system design?

easy

A. To avoid repeating code or design to keep systems simple

B. To write as much code as possible for clarity

C. To duplicate modules for faster development

D. To create multiple versions of the same component

Solution

1. Step 1: Understand the meaning of DRY

   DRY stands for "Don't Repeat Yourself," which means avoiding repeated code or design.

2. Step 2: Identify the goal of DRY

   The goal is to keep systems simple, maintainable, and reduce bugs by reusing components.

3. Final Answer:

   To avoid repeating code or design to keep systems simple -> Option A

4. Quick Check:

   DRY = Avoid repetition [OK]

Hint: DRY means write once, use many times [OK]

Common Mistakes:

• Thinking DRY means writing more code
• Believing duplication speeds development
• Confusing DRY with writing multiple versions

2. Which of the following is a correct way to follow DRY in system design?

easy

A. Creating reusable components or modules

B. Ignoring code reuse to save time

C. Writing separate code for each similar task

D. Copy-pasting the same code in multiple modules

Solution

1. Step 1: Identify DRY best practice

   DRY encourages reuse by creating components or modules that can be used multiple times.

2. Step 2: Evaluate options

   Copy-pasting or writing separate code repeats work, which breaks DRY. Ignoring reuse wastes effort.

3. Final Answer:

   Creating reusable components or modules -> Option A

4. Quick Check:

   Reuse = DRY [OK]

Hint: Reuse code with modules/components [OK]

Common Mistakes:

• Copy-pasting code instead of reusing
• Writing separate code for similar tasks
• Ignoring reuse to save time

3. Consider this pseudocode snippet following DRY:

function calculateTax(amount) {
  return amount * 0.1;
}

function calculateTotal(amount) {
  return amount + calculateTax(amount);
}

print(calculateTotal(100));

What is the output?

medium

A. 10

B. 100

C. 110

D. Syntax Error

Solution

1. Step 1: Calculate tax for amount 100

   Tax = 100 * 0.1 = 10

2. Step 2: Calculate total using tax

   Total = 100 + 10 = 110

3. Final Answer:

   110 -> Option C

4. Quick Check:

   100 + 10 = 110 [OK]

Hint: Add tax to amount using reusable function [OK]

Common Mistakes:

• Forgetting to add tax to amount
• Confusing tax amount with total
• Assuming syntax error without checking code

4. You see this code snippet violating DRY:

function sendEmailToUser1() {
  // send email logic
}

function sendEmailToUser2() {
  // send email logic
}

What is the best fix to follow DRY?

medium

A. Copy-paste send email logic in more functions

B. Create one function sendEmail(user) and reuse it

C. Keep both functions as is for clarity

D. Remove email sending completely

Solution

1. Step 1: Identify repeated code

   Both functions have the same email sending logic repeated.

2. Step 2: Refactor to reusable function

   Create one function with a parameter for user to reuse the logic.

3. Final Answer:

   Create one function sendEmail(user) and reuse it -> Option B

4. Quick Check:

   Refactor repeated code = DRY [OK]

Hint: Use parameters to reuse functions [OK]

Common Mistakes:

• Leaving duplicate functions unchanged
• Copy-pasting code more times
• Removing needed functionality

5. You design a system with multiple services needing user authentication. To follow DRY, which approach is best?

hard

A. Implement authentication logic separately in each service

B. Skip authentication to reduce complexity

C. Copy authentication code into each service for speed

D. Create a shared authentication service used by all services

Solution

1. Step 1: Identify repeated authentication logic

   Multiple services need the same authentication, so repeating code breaks DRY.

2. Step 2: Use a shared authentication service

   Centralizing authentication logic in one service allows reuse and easier maintenance.

3. Final Answer:

   Create a shared authentication service used by all services -> Option D

4. Quick Check:

   Shared service = DRY in system design [OK]

Hint: Centralize common logic in shared services [OK]

Common Mistakes:

• Duplicating authentication code in each service
• Skipping authentication for simplicity
• Copy-pasting code instead of sharing