Enhancing Object-Oriented Design Through Code Review Insights

Project Context

The obj1unq/2024s2-tp3-cami-n-Pichu224 project, which appears to be a system managing a 'truck' (camion) and various 'items' (cosas), recently underwent a comprehensive code review. This review provided valuable insights into improving the maintainability, robustness, and clarity of the object-oriented design within the system. The focus was on applying fundamental principles to enhance code quality and architectural integrity.

The Power of Descriptive Naming

One of the most immediate impacts on code readability comes from clear, descriptive naming. The review highlighted instances where methods could be renamed to better reflect their purpose, such as vaciarCarga() (empty cargo), totalBultosAlmacenados() (total stored packages), pesoTotalCosasGuardadas() (total weight of stored items), and cosaMasPeligrosa() (most dangerous item). Adopting precise names makes the code's intent self-documenting and easier for other developers to understand at a glance.

Leveraging Built-in Capabilities and Promoting Reuse

Effective use of a language's built-in collection methods can significantly simplify code and prevent unnecessary reimplementation of logic. The review pointed out opportunities to use methods like even() for checking even numbers or between(min, max) for range checks, thereby making the code more concise and less prone to errors. Furthermore, the importance of reusing existing methods instead of creating redundant filters or loops was emphasized, reinforcing the DRY (Don't Repeat Yourself) principle.

Eliminating Magic Numbers with Named Constants

Magic numbers—hardcoded numerical values embedded directly in the code—can obscure meaning and make future modifications difficult. The review recommended replacing such values, like 1000 (for 'tara' or tare weight) and 2500 (for 'pesoMaximo' or maximum weight), with named constants. This practice improves readability, makes the code easier to update, and centralizes important configuration values.

Smart Delegation of Responsibilities

A cornerstone of good object-oriented design is ensuring that objects are responsible for their own concerns and delegate appropriately. For example, a Truck object should not determine if a route is passable based on its cargo's danger level; instead, the Route object should provide that information. Similarly, the ability to unload items should be a responsibility of the Destination object, not the Truck itself. This promotes loose coupling and makes the system more modular and flexible.

Handling Nulls Gracefully

Returning null or initializing variables with null can lead to NullPointerException errors and force calling code to include defensive checks. The review advised against returning null when an item is not found; instead, suggesting default values or explicit validation to ensure an object is present before attempting to interact with it. Similarly, initializing objects with sensible defaults is preferred over null.

Considering State-Based Design Patterns

For objects with complex behaviors that change based on internal conditions, a state-based design pattern can offer a cleaner and more manageable solution. The review suggested exploring this approach, referencing a 'bumblebee' example, implying that modeling an object's life cycle or conditional behavior through distinct states can simplify logic that might otherwise become a tangled mess of if/else statements.

A Practical Example: Refactoring for Clarity and Reuse

Consider a scenario where a system needs to calculate the total weight of items or check if a condition is met across a collection. Initially, one might write verbose loops or duplicate filtering logic.

// Initial approach (conceptual)
calculateTotalWeight() {
    let total = 0;
    for each (item in items) {
        total = total + item.weight();
    }
    return total + 1000; // Magic number for tare weight
}

canPassRoute(route) {
    if (route.level() > this.cargoDangerLevel()) {
        return true;
    }
    return false;
}

By applying the principles discussed, this could be refactored to:

// Refactored approach (conceptual)
property tareWeight = 1000; // Named constant

calculateCargoWeight() = items.sum({ item => item.weight() }); // Reuse collection method

calculateTotalWeight() = this.calculateCargoWeight() + this.tareWeight; // Extract subtask, use constant

canPassRoute(route) = route.allows(this); // Delegate responsibility to the route

This refactored code is more readable, uses named constants, extracts subtasks, and delegates complex decisions, significantly improving its quality.

Conclusion

Code reviews are invaluable opportunities for learning and improvement. The insights from this particular review emphasize that focusing on clear naming, leveraging language features, eliminating magic numbers, delegating responsibilities, handling nulls gracefully, and considering state-based patterns are not just academic exercises. They are practical steps that lead to more robust, maintainable, and understandable software. By actively applying these object-oriented design principles, developers can elevate their code quality and contribute to more resilient systems.

Generated with Gitvlg.com