O que Aristóteles pode ensinar sobre Clean Code · lukaslumiere

Aristóteles provavelmente não sabia o que era um bug, mas ele definitivamente sabia como evitá-los. Há mais de 2.300 anos, o filósofo grego estava estabelecendo princípios sobre excelência e virtude que, surpreendentemente, se aplicam perfeitamente ao mundo da programação moderna.

Enquanto discutimos frameworks, arquiteturas e metodologias ágeis, talvez estejamos ignorando uma das bases mais sólidas para escrever bom código: a ética aristotélica. Sim, você leu certo. O mesmo cara que criou a lógica formal tem muito a nos ensinar sobre clean code.

As Quatro Virtudes Cardeais do Desenvolvedor

1. Temperança: A Arte de Não Complicar

Aristóteles definia temperança como a moderação, o autocontrole. No código, isso se traduz diretamente na luta contra a sobre-engenharia.

Quantas vezes você já viu (ou escreveu) uma classe com 47 métodos que "faz de tudo um pouco"? Ou aquela função que começou simples mas agora tem 15 parâmetros e "só mais uma feature pequenininha"?

// Sem temperança
class UserManagerFactoryBuilderService {
  createUserWithValidationAndNotificationAndLoggingAndCaching(
    userData: any,
    validationRules: any[],
    notificationConfig: any,
    logLevel: string,
    cacheOptions: any,
    // ... mais 10 parâmetros
  ) {
    // 200 linhas de código fazendo tudo
  }
}

// Com temperança
class User {
  constructor(private data: UserData) {}
}

class UserValidator {
  validate(user: User): ValidationResult {}
}

class UserNotifier {
  notify(user: User): void {}
}

A temperança nos ensina que fazer menos, mas fazer bem, é sempre melhor que tentar resolver todos os problemas do mundo em uma única classe.

2. Coragem: Refatorar Sem Medo

A coragem aristotélica não é a ausência do medo, mas agir corretamente apesar dele. No desenvolvimento, isso significa ter coragem para:

Refatorar aquele código legado que todo mundo tem medo de tocar
Fazer code reviews honestos, mesmo quando pode gerar conflito
Deletar código que você escreveu com carinho mas que não serve mais
Admitir quando não sabe e pedir ajuda

// Código que todo mundo tem medo de mexer
function processPayment(data: any): any {
  // 500 linhas de lógica complexa sem testes
  // "Se funciona, não mexe"
}

// Depois da coragem aristotélica
class PaymentProcessor {
  process(payment: Payment): PaymentResult {
    return this.pipeline
      .validate(payment)
      .calculateFees(payment)
      .processTransaction(payment)
      .sendNotification(payment);
  }
}

3. Justiça: Código Justo com o Próximo

Para Aristóteles, justiça era dar a cada um o que lhe pertence. No código, isso significa ser justo com quem vai mantê-lo - incluindo seu eu do futuro.

Código justo é aquele que:

Tem nomes descritivos que explicam o que e por que
Possui documentação onde realmente precisa
Segue convenções da equipe
Não esconde armadilhas ou efeitos colaterais

// Código injusto
const calc = (x: number, y: number, z?: boolean) => {
  // z ativa um modo especial que muda tudo
  return z ? x * y * 0.85 : x + y;
}

// Código justo
const calculateTotal = (price: number, quantity: number) => price * quantity;

const calculateTotalWithDiscount = (price: number, quantity: number) => {
  const LOYALTY_DISCOUNT = 0.85;
  return calculateTotal(price, quantity) * LOYALTY_DISCOUNT;
}

4. Prudência: A Sabedoria Prática

Aristóteles chamava a prudência de "phronesis" - a sabedoria prática, a capacidade de tomar as decisões certas no momento certo. No desenvolvimento, isso é escolher:

A tecnologia certa para o problema certo (não sempre a mais nova)
Quando otimizar e quando deixar simples
O nível certo de abstração para cada situação

O Meio-Termo: O Equilíbrio Aristotélico no Código

Uma das ideias mais poderosas de Aristóteles é a doutrina do meio-termo: a virtude está no equilíbrio entre extremos. Isso se aplica perfeitamente ao desenvolvimento:

Comentários: Entre o Silêncio e a Verbosidade

// Muito pouco (vício por falta)
const result = data.filter(x => x.status === 2 && x.type !== 'temp');

// Muito (vício por excesso)
// Esta função filtra os dados
// Ela pega cada item do array
// E verifica se o status é 2
// E também se o tipo não é 'temp'
// Depois retorna apenas os que passaram no filtro
const result = data.filter(x => x.status === 2 && x.type !== 'temp');

// Meio-termo (virtude)
// Filtra apenas pedidos aprovados que não são temporários
const approvedOrders = data.filter(order => 
  order.status === OrderStatus.APPROVED && 
  order.type !== OrderType.TEMPORARY
);

Abstração: Entre o Concreto e o Abstrato

// Muito concreto
function sendEmailToUserAboutOrder() { /* específico demais */ }

// Muito abstrato
function processEntity(entity: any, action: string) { /* genérico demais */ }

// Meio-termo
function notifyUser(user: User, notification: Notification) { /* na medida */ }

A Ética Nicomaqueia do Programador

Aristóteles dizia que "somos aquilo que fazemos repetidamente". A excelência, portanto, não é um ato, mas um hábito.

No desenvolvimento, isso significa que clean code não é algo que você faz uma vez e pronto. É o resultado de pequenas decisões diárias:

Escrever um teste antes de implementar
Refatorar quando você vê uma oportunidade
Escolher nomes descritivos, mesmo quando ninguém está olhando
Fazer commit com mensagens claras
Revisar seu próprio código antes de fazer push

// Hábitos que formam o caráter do desenvolvedor
class DeveloperHabits {
  
  // Hábito 1: Sempre começar com o teste
  writeTestFirst(requirement: Requirement): Test {
    return this.testFramework.describe(requirement.description);
  }
  
  // Hábito 2: Refatorar constantemente
  improveCodeDaily(codebase: Codebase): void {
    const smells = this.detectCodeSmells(codebase);
    smells.forEach(smell => this.refactor(smell));
  }
  
  // Hábito 3: Nomes descritivos sempre
  nameMeaningfully(concept: Concept): string {
    return concept.purpose + concept.context + concept.role;
  }
}

A Eudaimonia do Código

Aristóteles falava sobre eudaimonia - frequentemente traduzida como "felicidade", mas que significa mais precisamente "florescimento" ou "vida plena".

Um código eudaimônico é aquele que não apenas funciona, mas floresce:

É fácil de entender e modificar
Cresce de forma sustentável
Traz satisfação para quem trabalha com ele
Serve bem ao seu propósito

Conclusão

Aristóteles nos ensinou que "a excelência é um hábito, não um ato". Clean code também é isso - não é algo que você conquista uma vez, mas uma prática diária de fazer as pequenas escolhas certas.

Da próxima vez que você estiver escrevendo código, lembre-se do velho Aristóteles:

Pratique a temperança: faça simples
Tenha coragem: refatore quando necessário
Seja justo: pense em quem vai manter seu código
Use a prudência: escolha as ferramentas certas
Busque o meio-termo: evite extremos
Cultive bons hábitos: a excelência é uma prática diária

Afinal, se os princípios aristotélicos sobreviveram por mais de dois milênios, talvez eles tenham algo importante a nos ensinar sobre escrever código que também seja duradouro.