Ainda que você já tenha alguma afinidade com o desenvolvimento de software, certamente deve saber que a busca por qualidade de código é uma constante nesse universo.

São muitas as recomendações encontradas na internet, com dicas valiosas — e outras nem tanto — sobre como um bom código deve ser escrito. No entanto, algumas boas práticas de recomendação se sobressaem e passam a ditar o ritmo de como o dev precisa trabalhar.

Esse é o caso do livro Código Limpo, de Robert Martin, que busca ensinar valores da habilidade de um profissional de softwares para criar um programador melhor. 

Com base no livro, extraímos as 12 dicas práticas para criar código mais legível, objetivo e de alta qualidade. Continue lendo para conhecer cada uma das recomendações.

12 boas práticas da programação segundo o livro Código Limpo

Antes de entrarmos em cada um dos 12 itens, é importante ressaltar que aplicar as dicas, principalmente se você não tem muita experiência, pode ser extremamente desafiador. Por isso, vá adotando cada item de modo gradual para evoluir como um desenvolvedor.

Com o tempo, e muita paciência, você estará adotando as práticas com naturalidade. Inclusive, é exatamente essa uma das propostas do livro: adotar o processo de evolução como uma rotina, algo que faremos com naturalidade ao longo do tempo.

Dito isso, vamos conhecer as 12 boas práticas de programação para deixar seu código limpo:

1. Escreva código legível

O código legível é aquele que é fácil de entender à primeira vista. Isso envolve escolher nomes significativos para variáveis, funções e classes, de modo que o propósito e a função sejam claros. 

Além disso, o código deve ser formatado de maneira consistente e seguir convenções de estilo para facilitar a leitura e a manutenção. Essa prática pode ser difícil no início de carreira, mas deve ser uma busca constante.

2. Construa funções pequenas e coesas

Funções pequenas e coesas fazem uma única coisa e, geralmente, a fazem bem. Isso torna o código mais fácil de entender, testar e reutilizar. Funções grandes e complexas podem se tornar difíceis de compreender e podem acumular muitas responsabilidades, tornando a manutenção do software problemática.

3. Escolha nomes significativos para o código

Escolher nomes descritivos e significativos para variáveis, funções e classes é fundamental na criação de Código Limpo. Nomes bem escolhidos comunicam o propósito e a função do elemento no código, reduzindo a necessidade de comentários explicativos.

Indo além, eles permitem que outros desenvolvedores entendam o código sem qualquer tipo de problema, o que é ótimo para evitar a perda de tempo e criação de novas falhas.

4. Deixe comentários relevantes

Embora o objetivo seja escrever código autoexplicativo, como falamos acima, às vezes os comentários são necessários para esclarecer partes complexas ou decisões de design do código. 

Nesse sentido, os comentários devem explicar o porquê, a intenção ou a lógica por trás do código, em vez de simplesmente repetir o que o código faz. Quanto mais didático, melhor.

5. Use uma formatação consistente

A formatação consistente é vital para a legibilidade do Código Limpo. Manter um estilo de formatação consistente em todo o projeto facilita a leitura e ajuda os desenvolvedores a se concentrarem no conteúdo em vez de se preocuparem com a formatação.

A boa organização encurta o processo de compreensão do código, lembre-se disso.

6. Abuse dos testes unitários

Os testes unitários são parte essencial da garantia de qualidade do software. Eles ajudam a verificar se as partes individuais do código funcionam como deveriam. 

Um código com testes bem escritos proporciona confiança aos desenvolvedores para fazer alterações sem medo de introduzir erros. Mas, caso isso aconteça, os testes ajudarão a detectar e eliminar as novas falhas.

7. Adote o Princípio da Responsabilidade Única

O Princípio da Responsabilidade Única prega que uma classe ou função deve ter apenas uma única responsabilidade. Isso facilita a manutenção, pois alterações em uma responsabilidade não afetarão as outras. 

Classes e funções com uma única responsabilidade também tendem a ser mais reutilizáveis e, de maneira geral, cooperam para o sistema ser construído com um Código Limpo.

8. Aposte no princípio Aberto/Fechado

Esse princípio sugere que o código deve estar aberto para extensão, mas fechado para modificação. Isso significa que você pode adicionar novos recursos ou comportamentos através da criação de novas classes ou funções sem alterar o código existente. 

Isso ajuda a evitar efeitos colaterais não desejados, muito comuns em processos de desenvolvimento com baixa organização e pouca cobertura de testes automatizados.

9. Garanta o Princípio da Substituição de Liskov

O Princípio da Substituição de Liskov estabelece que as classes derivadas (subclasses) devem ser substituíveis por suas classes base (superclasses) sem afetar a funcionalidade do programa. 

Na prática, isso garante que as substituições de classes não quebrem o comportamento esperado do código, ou simplesmente adicionem complexidade de leitura e manutenção para outros devs.

10. Mantenha o Princípio da Inversão de Dependência

Esse princípio defende que módulos de alto nível não devem depender de módulos de baixo nível, mas ambos devem depender de abstrações. Isso promove um design mais flexível e desacopla as partes do sistema, tornando-o mais fácil de modificar e manter.

11. Elimine a duplicação de código

Duplicação de código resulta em manutenção difícil e inconsistências — fatores que são contra as premissas do código limpo. Eliminar duplicações promove a consistência e evita a necessidade de fazer alterações em vários lugares quando requisitos mudam.

E acredite, isso ainda acontece em muitos softwares criados por profissionais com pouca experiência. Então, internalize essa regra e evite cair nessa armadilha.

12. Controle a complexidade

Controlar a complexidade do código é crucial em todos os sentidos. Funções pequenas, nomes significativos, princípios de design sólidos e escolha de abstrações adequadas contribuem para manter a complexidade sob controle. 

Isso facilita a manutenção e evita que o código se torne difícil de entender. Além disso, vai reduzir a chance de bugs inesperados aparecerem. Portanto, toda a complexidade deve ser abolida do sistema.

Escrever código limpo é um processo

Lembre-se que as dicas trazidas ao longo deste conteúdo não vão, automaticamente, te tornar um desenvolvedor sênior, mas certamente te colocarão no caminho para tal função.

Muito além do cargo, um desenvolvedor sênior é aquele que tem condições de escrever um código fácil de compreender, sem complexidades e que não atrapalhe a evolução do sistema.

Portanto, adotar a cultura do Código Limpo faz parte das boas práticas de programação que um profissional do desenvolvimento precisa ter.

Quer conhecer outras dicas para melhorar na profissão? Não deixe de conferir: Como desenvolver um software de qualidade: 4 princípios para melhorar o produto