El capítulo 12 de Clean Code, titulado "Emergencia", explora cómo el software limpio y bien estructurado surge de la adhesión a principios de diseño fundamentales.

La aparición en el diseño de software se refiere al proceso mediante el cual un comportamiento o funcionalidad compleja surge de reglas simples y bien entendidas.

Seguir estas reglas puede ayudar a los desarrolladores a crear software que sea fácil de mantener, ampliar y comprender.

Este capítulo se centra en las cuatro reglas del diseño simple, enfatizando la simplicidad y la capacidad de prueba para un código limpio y eficiente.

? Las cuatro reglas del diseño simple

• Pasa todas las pruebas
• Revela intención
• Sin duplicación
• Minimiza el número de clases y métodos

Desglosemos cada una de estas reglas y veamos cómo se aplican usando JavaScript.

1. Pasa todas las pruebas

La base de un software limpio y emergente es que debe ser funcional.

Todo el código debe pasar sus pruebas, asegurando que se conserve el comportamiento esperado y que la nueva funcionalidad no introduzca errores.

En JavaScript, esto a menudo se logra escribiendo pruebas unitarias con bibliotecas como Jest o Mocha.

function add(a, b) {
  return a   b;
}

// Test (using Jest)
test('adds 1   2 to equal 3', () => {
  expect(add(1, 2)).toBe(3);
});

Al asegurarse de que el software pase todas las pruebas, garantiza que el sistema funcione según lo previsto.

El código limpio comienza con pruebas confiables. Sin esto, ninguna de las otras reglas importa.

2. Revela intención

El código debe comunicar lo que hace. Las funciones, variables y clases bien nombradas pueden hacer que su código sea fácil de leer y comprender sin necesidad de comentarios.

El código que revela su intención se explica por sí mismo.

Mal nombre:

function d(x) {
  return x * 2;
}

Buen nombramiento:

function doubleNumber(number) {
  return number * 2;
}

En este caso, doubleNumber() revela claramente la intención de la función.

Cualquier persona que lea este código puede comprender inmediatamente su propósito sin explicaciones adicionales.

Esta práctica no solo reduce la confusión sino que también mejora la mantenibilidad.

3. Sin duplicación

La duplicación de código es uno de los mayores enemigos del software limpio. La lógica repetida puede provocar errores y un mayor esfuerzo de mantenimiento.

El objetivo es reducir la redundancia abstrayendo comportamientos comunes en funciones o módulos reutilizables.

Duplicación de código:

function calculateAreaOfSquare(side) {
  return side * side;
}

function calculateAreaOfRectangle(length, width) {
  return length * width;
}

Ambas funciones realizan cálculos similares. Al refactorizar, podemos eliminar la duplicación.

Sin duplicación:

function calculateArea(shape) {
  if (shape.type === 'square') {
    return shape.side * shape.side;
  } else if (shape.type === 'rectangle') {
    return shape.length * shape.width;
  }
}

Al generalizar la función, eliminamos la lógica repetida y hacemos que el código sea más fácil de mantener.

4. Minimiza el número de clases y métodos

La última regla del diseño simple fomenta la minimización del número de clases y métodos sin sacrificar la claridad.

Esto significa evitar complejidades innecesarias.

Cada clase o función debe tener una responsabilidad clara y enfocada, apegándose al Principio de Responsabilidad Única (SRP).

Demasiados métodos:

class User {
  constructor(name) {
    this.name = name;
  }

  getName() {
    return this.name;
  }

  setName(name) {
    this.name = name;
  }

  printWelcomeMessage() {
    console.log(`Welcome, ${this.name}!`);
  }

  // Additional unrelated methods
  getUserProfile() {
    // ... some logic
  }

  logActivity() {
    // ... some logic
  }
}

Esta clase tiene demasiadas responsabilidades. Debería centrarse únicamente en gestionar el nombre del usuario.

Refactorizado:

class User {
  constructor(name) {
    this.name = name;
  }

  getName() {
    return this.name;
  }

  setName(name) {
    this.name = name;
  }
}

class Logger {
  static logActivity(user) {
    // ... some logic
    console.log(`${user.getName()} performed an activity.`);
  }
}

Al separar las preocupaciones, el código se vuelve más simple y fácil de mantener.

Ahora, cada clase tiene una única responsabilidad, apegándose a los principios de minimalismo y sencillez.

Conclusión

Las cuatro reglas del diseño simple (pasar todas las pruebas, revelar la intención, eliminar la duplicación y minimizar el número de clases y métodos) guían la creación de código limpio, mantenible y emergente.

Al seguir estos principios, la complejidad se mantiene bajo control y su código se vuelve más adaptable al cambio.

¡Feliz codificación!