Applying Clean Code Principles with Ruby: Embracing the DRY Principle

Welcome to the very first lesson of the "Applying Clean Code Principles" course! In this lesson, we will focus on a fundamental concept in clean coding: the DRY ("Don't Repeat Yourself") principle. Understanding DRY is crucial for writing efficient, maintainable, and clean code. This principle is not just important for coding interviews but also in everyday software development. Today, we will dive deep into issues caused by repetitive code and explore strategies to combat redundancy. 🚀

Repetitive functionality in code can introduce several issues that affect the efficiency and maintainability of your software:

• Code Bloat: Repeating similar code across different parts of your application unnecessarily increases the size of the codebase. This makes the code harder to navigate and increases the chances of introducing errors.

• Risk of Inconsistencies: When similar pieces of logic are scattered across different areas, it's easy for them to become out of sync during updates or bug fixes. This can result in logic discrepancies and potentially introduce new problems.

• Maintenance Challenges: Updating code often requires modifications in multiple places, leading to increased work and a higher likelihood of errors. Redundant code makes it difficult for developers to ensure all necessary changes have been made consistently.

To adhere to the DRY principle and avoid repeating yourself, several strategies can be employed:

• Extracting Method: Move repeated logic into a dedicated method that can be called wherever needed. This promotes reuse and simplifies updates.

• Extracting Variable: Consolidate repeated expressions or values into variables. This centralizes change, reducing the potential for errors.

• Replace Temp with Query: Use a method to compute values on demand rather than storing them in temporary variables, aiding in readability and reducing redundancy.

Consider the following problematic code snippet where repetitive logic is used for calculating the total price based on different shipping methods:

def calculate_click_and_collect_total(order)
  items_total = 0
  # Iteration to calculate items_total
  order.items.each do |item|
    items_total += item.price * item.quantity
  end
  shipping_cost = items_total > 100 ? 0 : 5
  items_total + shipping_cost + order.tax
end

def calculate_post_shipment_total(order, is_express)
  items_total = 0
  # Duplicate: Iteration to calculate items_total
  order.items.each do |item|
    items_total += item.price * item.quantity
  end
  shipping_cost = is_express ? items_total * 0.1 : items_total * 0.05
  items_total + shipping_cost + order.tax
end

Both methods contain duplicated logic for calculating the total price of items, making them error-prone and hard to maintain. Now, let's refactor this code.