Sprout Method - When a Method Does Too Much

Introduction

Now that we have had a warm-up with the sprout method technique, let's explore another use case for it. We'll focus on another crucial aspect of refactoring: identifying and addressing methods that do too much. This lesson will guide us through the process of recognizing overloaded methods and using the sprout method to refactor them, ensuring our code remains clean, efficient, and maintainable.

Identifying Overloaded Methods

Methods that handle multiple responsibilities can be challenging to manage and understand. These overloaded methods often violate the single responsibility principle, which states that a method should have only one reason to change. Recognizing such methods is the first step in refactoring. We should look for methods that perform several distinct tasks or have multiple logical sections. These are indicators that a method might be doing too much and could benefit from refactoring. Overloaded methods can lead to several problems. They reduce code readability, making it difficult for developers to understand the method's purpose at a glance. This complexity can also increase the likelihood of bugs, as changes to one part of the method might inadvertently affect another.

Refactoring with the Sprout Method

The sprout method offers a structured approach to refactoring overloaded methods. By extracting portions of a method into new, focused methods, we can adhere to the single responsibility principle. Here's a step-by-step guide: Identify Distinct Responsibilities : We examine the method to identify different tasks it performs. Create New Methods : For each distinct responsibility, we create a new method that encapsulates that functionality. Even if it's a single line, extracting it enhances clarity and maintainability. This allows us to give the logic a descriptive name and provides a convenient place to expand functionality in the future. Refactor the Original Method : We replace the extracted logic in the original method with calls to the new methods, ensuring it remains focused and concise. In the previous lesson, we used the sprout method to introduce new functionality without affecting existing logic, ensuring stability while expanding capabilities. In contrast, when applied to overloaded methods, the sprout method focuses on refactoring by breaking down a method with multiple responsibilities into smaller, focused methods. While both uses aim to improve code quality, the former emphasizes stability during expansion, and the latter focuses on reducing complexity and enhancing clarity.

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Real-World Example

Let's examine a complex order processing logic that handles multiple responsibilities:

Scala

import java.time.LocalDateTime
import scala.util.Try

class OrderProcessor(dbConnection: DatabaseConnection, paymentGateway: PaymentGateway, emailService: EmailService):

  def processOrder(order: Order): Boolean =
    Try:
      val customerOpt = dbConnection.getCustomerById(order.customerId)
      customerOpt match
        case Some(customer) =>
          val totalAmount = order.items.foldLeft(BigDecimal(0)): (total, item) =>
            dbConnection.getProductById(item.productId) match
              case Some(product) =>
                val itemPrice = product.price * item.quantity * (if customer.isPremium then 0.9 else 1.0)
                total + itemPrice
              case None => total

          val paymentResult = paymentGateway.processPayment(totalAmount)
          if paymentResult.success then
            dbConnection.updateOrderStatus(order.customerId, "Paid")
            order.processedAt = Some(LocalDateTime.now)
            emailService.sendOrderConfirmation(customer.email, order.customerId, totalAmount)
            true
          else false
        case None => false
    .getOrElse:
      println(s"Error processing order")
      false

import java.time.LocalDateTime
import scala.util.Try

class OrderProcessor(dbConnection: DatabaseConnection, paymentGateway: PaymentGateway, emailService: EmailService):

  def processOrder(order: Order): Boolean =
    Try:
      val customerOpt = dbConnection.getCustomerById(order.customerId)
      customerOpt match
        case Some(customer) =>
          val totalAmount = order.items.foldLeft(BigDecimal(0)): (total, item) =>
            dbConnection.getProductById(item.productId) match
              case Some(product) =>
                val itemPrice = product.price * item.quantity * (if customer.isPremium then 0.9 else 1.0)
                total + itemPrice
              case None => total

          val paymentResult = paymentGateway.processPayment(totalAmount)
          if paymentResult.success then
            dbConnection.updateOrderStatus(order.customerId, "Paid")
            order.processedAt = Some(LocalDateTime.now)
            emailService.sendOrderConfirmation(customer.email, order.customerId, totalAmount)
            true
          else false
        case None => false
    .getOrElse:
      println(s"Error processing order")
      false

This method handles multiple tasks: fetching customer data, calculating the order total, processing payment, updating order status, and sending a confirmation email. By applying the sprout method, we can refactor this into smaller methods, each handling a specific responsibility.

For example, we might extract the logic for updating order status to a separate method:

Scala

private def updateOrderStatus(order: Order): Unit =
  dbConnection.updateOrderStatus(order.customerId, "Paid")
  order.processedAt = Some(LocalDateTime.now)

private def updateOrderStatus(order: Order): Unit =
  dbConnection.updateOrderStatus(order.customerId, "Paid")
  order.processedAt = Some(LocalDateTime.now)

We would then call this method in place of the logic that it contains within the processOrder method. This not only makes the code more readable but also easier to test and maintain. We will focus on doing just that in the upcoming practice sessions.

Introduction

Identifying Overloaded Methods

Refactoring with the Sprout Method

Join the 1M+ learners on CodeSignal

Benefits of the Sprout Method

Real-World Example

Summary and Preparation for Practice Exercises