O Capítulo 12 do Código Limpo, intitulado "Emergência", explora como um software limpo e bem estruturado emerge da adesão aos princípios fundamentais de design.

O surgimento no design de software refere-se ao processo através do qual comportamento ou funcionalidade complexa surge de regras simples e bem compreendidas.

Seguir essas regras pode ajudar os desenvolvedores a criar software que seja fácil de manter, estender e entender.

Este capítulo se concentra nas Quatro Regras do Design Simples, enfatizando a simplicidade e a testabilidade para um código limpo e eficiente.

? As quatro regras do design simples

• Passa em todos os testes
• Revela intenção
• Sem duplicação
• Minimiza o número de classes e métodos

Vamos analisar cada uma dessas regras e ver como elas se aplicam usando JavaScript.

1. Passa em todos os testes

A base do software limpo e emergente é que ele deve ser funcional.

Todo código deve passar nos testes, garantindo que o comportamento esperado seja preservado e que novas funcionalidades não introduzam bugs.

Em JavaScript, isso geralmente é conseguido escrevendo testes de unidade com bibliotecas como Jest ou Mocha.

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

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

Ao garantir que o software passe em todos os testes, você garante que o sistema funcione conforme planejado.

Código limpo começa com testes confiáveis. Sem isso, nenhuma das outras regras importa.

2. Revela intenção

O código deve comunicar o que faz. Funções, variáveis ​​e classes bem nomeadas podem tornar seu código fácil de ler e entender sem a necessidade de comentários.

O código que revela sua intenção é autoexplicativo.

Nomeação incorreta:

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

Boa nomenclatura:

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

Nesse caso, doubleNumber() revela claramente a intenção da função.

Qualquer pessoa que leia este código pode entender imediatamente seu propósito, sem explicações adicionais.

Essa prática não apenas reduz a confusão, mas também melhora a capacidade de manutenção.

3. Sem duplicação

A duplicação de código é um dos maiores inimigos do software limpo. Lógica repetida pode levar a bugs e aumentar o esforço de manutenção.

O objetivo é reduzir a redundância abstraindo comportamentos comuns em funções ou módulos reutilizáveis.

Duplicação de código:

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

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

Ambas as funções estão fazendo cálculos semelhantes. Ao refatorar, podemos eliminar a duplicação.

Sem duplicação:

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

Ao generalizar a função, eliminamos a lógica repetida e tornamos o código mais sustentável.

4. Minimiza o número de classes e métodos

A última regra do design simples incentiva a minimização do número de classes e métodos sem sacrificar a clareza.

Isso significa evitar complexidade desnecessária.

Cada classe ou função deve ter uma responsabilidade clara e focada, aderindo ao Princípio da Responsabilidade Única (SRP).

Muitos 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 classe tem muitas responsabilidades. Deve se concentrar apenas no gerenciamento do nome do usuário.

Refatorado:

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.`);
  }
}

Ao separar as preocupações, o código se torna mais simples e fácil de manter.

Agora, cada turma tem uma responsabilidade única, aderindo aos princípios do minimalismo e da simplicidade.

Conclusão

As quatro regras do design simples – passar em todos os testes, revelar a intenção, eliminar a duplicação e minimizar o número de classes e métodos – orientam a criação de código limpo, sustentável e emergente.

Seguindo esses princípios, a complexidade é mantida sob controle e seu código se torna mais adaptável às mudanças.

Boa codificação!