A busca por um código simples, manutenível e legível sempre foi o foco do meu desenvolvimento. Desde meu estágio, quando tive contato com boas práticas em uma célula de QA, busco constantemente aprimorar minha lógica e “gramática” de código. Ao estudar o livro ‘Clean Code’, de Robert C. Martin, fiz anotações que memorizei e utilizei a partir dai até os dias de hoje. Neste artigo, não trago muitas reflexões somente minha lista pessoal de anotações com base na leitura que fiz.

Falando em Nomes

Significativos: Evite nomes confusos ou abreviações excessivas. Use nomes que indiquem claramente o propósito da variável, função ou classe. Exemplo: idadeDoUsuario é melhor que idUsu.

Consistentes: Se você usar idadeDoUsuario em uma parte do código, use o mesmo nome em outras partes, em vez de idadeUsuario ou idade.

Pesquisáveis: Números mágicos são valores numéricos usados diretamente no código sem explicação. Use constantes com nomes descritivos ao invés de números mágicos. Exemplo: const IDADE_MINIMA = 18; é melhor que if (idade > 18).

Pensando em Funções

Pequenas e de Responsabilidade Única: Funções curtas são mais fáceis de entender e testar. Cada função deve ter um propósito claro e bem definido.

Nomes Descritivos: Use verbos que descrevam a ação realizada pela função. Exemplo: calcularIdade() é melhor que idade().

Argumentos Mínimos: vise a zero ou um argumento → Funções com muitos argumentos são complexas e difíceis de testar.

Cuidado com Efeitos Colaterais: evite modificar variáveis fora do escopo da função, a menos que seja o objetivo principal. Efeitos colaterais inesperados podem causar bugs difíceis de encontrar.

#Fazer ou Não fazer Comentários? Explique Porquê, Não O Quê: Use nomes descritivos e código claro para que o código se explique. Comentários devem explicar o “porquê” de uma decisão de design ou lógica complexa.

Atualizados: Mantenha os comentários atualizados com o código.

Evite Comentários Óbvios: não declare o óbvio, comentários como // incrementa a variável x são desnecessários.

Sem Código Comentado: Ferramentas de controle de versão (como o Git) permitem rastrear as alterações no código.

#Uma boa Formatação Consistência: Use um guia de estilo para garantir a consistência na formatação do código.

Densidade Vertical: Linhas em branco melhoram a legibilidade do código.

Formatação Horizontal: Use recuo para mostrar a estrutura do código e espaçamento para separar os elementos.

Formatação de Equipe: Toda a equipe deve seguir o mesmo guia de estilo.

Objetos e Estruturas de Dados do jeito Certo!

Encapsulamento: Proteja os dados internos de um objeto e forneça métodos para acessá-los e modificá-los.

Dados sobre Primitivos: Classes permitem agrupar dados e comportamento relacionados.

Diga, Não Pergunte: Em vez de perguntar a um objeto sobre seu estado e tomar decisões com base nisso, diga ao objeto o que fazer.

Lei de Demeter: Evite acessar objetos indiretamente através de outros objetos, lembre-se: um objeto deve falar apenas com suas dependências.

Tratando os Erros

Exceções acima de Códigos de Retorno: Exceções permitem lidar com erros de forma estruturada.

Exceções Específicas: Use exceções específicas para cada tipo de erro.

Mensagens Claras e Objetivas: Mensagens de erro informativas ajudam na depuração.

Falha Rápida, Correção Rápida: Não ignore ou oculte erros. Lide com eles o mais rápido possível.

Cuidando das Classes

Classes Pequenas e Coesas: Classes grandes e complexas são difíceis de entender e manter, lembre-se: Pequenas e de Responsabilidade Única.

Organizado para Mudança: Oculte os detalhes da implementação para que as mudanças não afetem outras partes do código.

Injeção de Dependência: Injeção de dependência torna o código mais flexível e fácil de testar.

Sistemas e suas Complexidades

Separação de Contextos: Cada módulo deve ter um propósito específico e bem definido.

Testabilidade: Escreva código que seja fácil de testar desde o início.

Um Passo de Cada Vez: Melhore o código continuamente por meio de pequenas refatorações.

Testes de Unidade

Testes Clean: Aplique os princípios de código limpo aos seus testes.

Reduza a Complexidade: Torne o código mais testável por meio de refatoração.

F.I.R.S.T.: Escreva testes que sejam rápidos de executar, independentes uns dos outros, repetíveis, capazes de se validar e escritos no momento certo. Ou seja, Fast (Rápido), Independent (Independente), Repeatable (Repetível), Self-Validating (Autovalidado) e Timely (Oportuno).

Uma Afirmação por Teste: Testes com muitas afirmações são difíceis de entender e manter.