Simplifying Code Complexity: The Power of Shallow Methods

When it comes to writing clean and maintainable code, one of the most effective strategies is to keep methods shallow. This approach, part of Object Calisthenics, emphasizes limiting indentation to a single level per method. By doing so, you break down complex logic into smaller, more manageable pieces, enhancing readability, testability, and maintainability.

Why Shallow Methods Matter

Deeply nested code can quickly become overwhelming, making it difficult to understand and debug. By keeping methods shallow, you:

• Improve Readability: Shallow methods are easier to grasp at a glance.
• Promote Single Responsibility: Each method focuses on a single task.
• Simplify Debugging: Smaller methods reduce the scope of potential bugs.
• Enhance Reusability: Extracted logic can be reused across your codebase.

Aligning with the Single Point of Truth Principle

This rule also aligns with the Single Point of Truth (SPOT) principle. By isolating logic in smaller methods, you ensure that specific operations are defined in only one place, reducing redundancy and inconsistencies.

Example: Processing Orders

func processOrders(orders: [Order]) {
    for order in orders {
        if order.isValid {
            if order.isPaid {
                print("Processing order: \(order.id)")
            } else {
                print("Order not paid: \(order.id)")
            }
        } else {
            print("Invalid order: \(order.id)")
        }
    }
}        

Let's refactor it to adhere to the shallow method rule:

func processOrders(orders: [Order]) {
    for order in orders {
        processOrder(order)
    }
}

private func processOrder(_ order: Order) {
    guard order.isValid else {
        print("Invalid order: \(order.id)")
        return
    }

    guard order.isPaid else {
        print("Order not paid: \(order.id)")
        return
    }

    print("Processing order: \(order.id)")
}        

Example: Handling User Authentication

func authenticateUser(username: String, password: String) -> Bool {
    if !username.isEmpty && !password.isEmpty {
        if username == "admin" && password == "1234" {
            return true
        }
    }
    return false
}        

Refactor:

func authenticateUser(username: String, password: String) -> Bool {
    guard !username.isEmpty, !password.isEmpty else {
        return false
    }
    return isValidCredentials(username: username, password: password)
}

private func isValidCredentials(username: String, password: String) -> Bool {
    return username == "admin" && password == "1234"
}        

Example: Validating Form Input

func validateForm(name: String, age: Int) -> Bool {
    if !name.isEmpty {
        if age > 0 && age < 120 {
            return true
        }
    }
    return false
}        

In this example, the logic is nested with multiple if statements, making the code harder to read and maintain.

Refactor:

func validateForm(name: String, age: Int) -> Bool {
    guard isValidName(name), isValidAge(age) else {
        return false
    }
    return true
}

private func isValidName(_ name: String) -> Bool {
    return !name.isEmpty
}

private func isValidAge(_ age: Int) -> Bool {
    return age > 0 && age < 120
}        

Benefits of Shallow Methods

• Clear Flow: The main method clearly shows the loop and delegates details.
• Reduced Complexity: Each function handles a single task without deep nesting.
• Improved Testability: Smaller functions are easier to isolate and test.
• Single Point of Truth: Each decision is handled in a dedicated method, reducing duplication.

Techniques to Limit Indentation

1. Use Guard Clauses: Exit early when conditions are not met.
2. Extract Methods: Move complex logic into smaller, private methods.
3. Use Polymorphism: Replace conditional branches with specialized classes.
4. Apply Strategy Pattern: Delegate decisions to different strategy implementations.

Flexibility in Real-World Scenarios

While adhering to this rule generally improves code quality, there are situations where minor nesting may enhance clarity, such as small loops, switch statements or performance-critical sections.

Conclusion

The "Only One Level of Indentation Per Method" rule is a powerful tool for writing cleaner and more maintainable code. By embracing this discipline, you foster better code organization, making it easier to collaborate and extend your projects. In the next article, we'll explore the second rule: Don't Use the else Keyword.