Clean Code: como ser bem-sucedido em programação?

Introdução

Aprender técnicas de Clean Code pode ser um grande diferencial para se destacar na área de Tecnologia da informação. Isso se deve ao fato de que essa prática aprimora a qualidade do software e facilita o trabalho em equipe.

O conhecimento em Clean Code é altamente valorizado no mercado de TI, uma vez que empresas buscam profissionais que se destacam pela habilidade de criar e manter sistemas que são fáceis de entender e evoluir, tornando a equipe de desenvolvimento mais produtiva. 

Você já se deparou com a situação de pegar um código de algum colega e achar o algoritmo muito confuso e nebuloso? Nós, como desenvolvedores, temos a ciência de que a manutenibilidade e a legibilidade do código são fundamentais para o sucesso dos projetos de software. 

A falta da implementação de Clean Code pode ser prejudicial em vários aspectos. Inicialmente, quando tratamos de códigos complexos / mal estruturados / difíceis de entender, a manutenção se torna uma tarefa árdua e dispendiosa, resultando em atrasos na implementação de novos recursos.

Além disso, equipes de desenvolvimento sobrecarregadas com código “sujo” têm maior probabilidade de introduzir erros, o que resulta em produtos finais com falhas e insatisfação do cliente. 

A falta de padronização e boas práticas de codificação torna, também, a colaboração mais desafiadora, à medida que os desenvolvedores lutam para entender os códigos uns dos outros.

Portanto, a promoção de práticas de Clean Code torna-se um elemento crítico para o sucesso no desenvolvimento de softwares. Implementando a programação limpa, os principais benefícios observados são: economia de recursos, satisfação do cliente, manutenibilidade aprimorada, qualidade aumentada, etc.  

Neste artigo, abordaremos a importância de usar o Clean Code, que é a arte de escrever códigos fáceis de ler. Ademais, alguns dos principais atributos do Clean Code são: o código é simples de entender e parece ter sido escrito por alguém que tem diligência, é eficiente e bem organizado.

O que você vai aprender neste artigo: 

• arquitetura Clean Code
• princípios fundamentais
• exemplos práticos
• boas práticas de formatação
• injeção de dependências
• testes unitários
• design SOLID
• integração e entrega contínua (CI/CD)
• refatoração de código
• Padrões de nomenclaturas 

Arquitetura Clean Code

A arquitetura Clean Code é uma filosofia de design que separa os elementos em níveis circulares. Além de estruturar o código de maneira a promover a clareza e a manutenibilidade. Um exemplo é a arquitetura em camadas, que divide o sistema em partes coesas, facilitando a manutenção e a expansão.

Princípios fundamentais

Os princípios do Clean Code são os pilares que sustentam a qualidade do código:

1) Nomes Significativos para variáveis  funções 

A escolha de nomes que descrevem com clareza variáveis, funções, classes e outros identificadores é importante para transmitir o propósito da entidade, tornando o código mais compreensível.

Exemplo de uso não recomendado utilizando a linguagem Python:

tau = 105

Exemplo de uso recomendado utilizando a linguagem Python:

total_active_users = 105

2) Manter Funções Pequenas

Funções pequenas e concisas com objetivos bem definidos facilitam a compreensão e a manutenção do código. A regra geral é que uma função deve fazer apenas uma coisa, para que, dessa forma, consiga fazê-la bem.

Exemplo de uso recomendado utilizando a linguagem Python:

def display_users(users):
for user in users:
      print(user)

3) Evitar códigos duplicados 

É essencial a eliminação de repetições, uma vez que códigos repetidos aumentam inconsistências. Em vez de copiar e colar o mesmo código, devemos encapsulá-lo em funções ou classes para promover a reutilização. Desse modo, diminui o trabalho no caso de o código precisar de alterações.

4) Comentários concisos

Os comentários são importantes, entretanto devem ser usados com moderação. Esses servem para auxiliar outros desenvolvedores a entender o algoritmo.  Em contrapartida, é recomendável que o código seja autoexplicativo sempre que for viável.

Exemplo de uso não recomendado utilizando a linguagem Python:

x = x + 1  # incrementa x

Exemplo de uso recomendado utilizando a linguagem Python:

# Calcula o score  total incrementando x
total_score = x + 1

5) Formatação e indentação consistentes

Um código com formatação e recuos coerentes fazem que o código aparente seja organizado. Em conformidade, a maioria das linguagens possuem padrões a serem seguidos.  

6) Uso de espaços em branco de forma intencional e com significado 

Formatar o código com espaços e quebras de linha melhora a legibilidade. Algoritmos bem formatados são mais fáceis de digitalizar, tornando a informação mais fácil de ser compreendida e absorvida pelos leitores, diminuindo a quantidade de esforço mental necessária para processar o conteúdo.

7) Manipulação de erros 

É essencial lidar com os erros de forma adequada. Certifique-se de usar blocos try-catch ou mecanismos apropriados de tratamento de erros em seu código, o que poderá evitar falhas e fornecerá informações úteis. Outrossim, evite suprimir erros ou apenas registrá-los sem fornecer uma resposta adequada.

8) Testes 

Opte por utilizar testes unitários para verificar a exatidão do seu código.  O desenvolvimento orientado a testes (TDD) pode ajudá-lo a escrever um código mais limpo, forçando-o a considerar antecipadamente casos extremos e o comportamento esperado. 

9) Refatoração 

É imprescindível que o código seja refatorado regularmente. Quando necessário, altere o programa à medida que os requisitos e a compreensão do domínio do problema fiquem obsoletos. A refatoração ajuda a manter o código limpo conforme o projeto evolui.

10) Controle de versão 

Utilize sistemas de controle de versão, como o Git, para acompanhar as modificações do código. Isso permitirá o eficiente trabalho em equipe, possibilitando que, caso necessário, o código seja revertido para versões anteriores, além de manter um histórico organizado do desenvolvimento do projeto.

Exemplos práticos

A melhor maneira de entender o Clean Code é através de exemplos práticos. Portanto, a seguir analisaremos um trecho de código na linguagem de programação Python que segue alguns dos princípios discutidos:

def calcular_media(lista_numeros):
  soma = 0
  for i in range(len(lista_numeros)):
      soma += lista_numeros[i]
  return soma / len(lista_numeros)

print(calcular_media([1, 2, 3, 4, 5]))

Este código utiliza nomes que descrevem com clareza o papel das variáveis e da função, além de definir uma função pequena e evitar  a repetição de lógica.

Boas Práticas de Formatação de Código

Manter um código bem organizado é essencial. Isso envolve seguir um conjunto de regras de formatação, semelhante a seguir um manual de estilo de escrita. Por exemplo, em Python, há o PEP 8, que é como um guia de estilo que ajuda a manter o código legível e simples de cuidar.

Ferramentas para análise de código

O uso de Ferramentas focadas na análise de código são de suma importância por  oferecerem suporte aos desenvolvedores na identificação de problemas e desvios das melhores práticas de codificação. 

Um exemplo é o ESLint, amplamente utilizado no ecossistema JavaScript. O ESLint é uma ferramenta de análise de código que verifica o algoritmo em busca de erros, problemas de estilo e violações de regras específicas do projeto, permitindo a identificação de problemas.

Em projetos na linguagem Java, temos o uso do Checkstyle que é um analisador estático que verifica o código em relação a diretrizes de codificação específicas, destacando áreas que precisam de melhoria e identificando violações de padrões de código. 

Por meio do Checkstyle, é possível averiguar códigos duplicados, espaços entre caracteres, convenções nos nomes de atributos / métodos, comentários javadoc, boas práticas no desenvolvimento de classes, limite no número de parâmetros, etc.  

Por fim, o SonarQube é uma ferramenta valiosa, que suporta várias linguagens de programação e garante a qualidade do código-fonte em desenvolvimento, detectando trechos que possam apresentar bugs, duplicidades e problemas de segurança.

Estes são alguns exemplos de ferramentas que capacitam equipes de desenvolvimento a manter o Clean Code. No entanto, vale ressaltar que essas ferramentas são complementares à revisão de código.

Ademais,  o uso eficaz dessas aplicações requer uma compreensão sólida dos princípios do Clean Code para interpretar e agir sobre as informações fornecidas. Percebe-se, então, a importância em investir no estudo dos princípios com o fito de alcançar excelência na programação.

Portanto, ao combinar o conhecimento humano com ferramentas de análise de código, os desenvolvedores podem garantir que seus projetos alcancem o Clean Code, resultando em softwares de alta qualidade e fácil manutenção.

Injeção de Dependências

A injeção de dependências é uma técnica crucial para criar códigos limpos e altamente testáveis. Essa pode ser realizada de várias maneiras (como por construtor ou por interface), tornando as dependências explícitas e facilitando a substituição de implementações, promovendo a flexibilidade.

Testes Unitários 

Os testes de unidade são fundamentais para a metodologia Clean Code. Esses garantem que o código seja confiável e atenda aos requisitos do projeto. 

Em um contexto de desenvolvimento com foco na qualidade, identificam potenciais problemas, sendo essencial para manter o código limpo, uma vez que permite a detecção precoce de problemas e facilita a refatoração quando necessário.

Além disso, os testes de unitários promovem a simplicidade que é um dos princípios-chave do Clean Code. Ao escrever estes testes, os desenvolvedores separam o código em partes menores, tornando-o mais simples e claro. 

Cada teste de unidade se concentra em verificar uma única funcionalidade, tornando mais fácil identificar e corrigir problemas específicos, mantendo o código coeso e conciso.

Consecutivamente, o desenvolvimento orientado a testes (TDD)  garante que o código seja confiável, legível e fácil de manter, promovendo a simplicidade e a modularidade.

Ademais, à medida que o código evolui, os testes atuam como um mecanismo de verificação contínua, garantindo que o código permaneça limpo e livre de erros à proporção que novos recursos são adicionados ou modificações são feitas. 

Portanto, no mundo do Clean Code, os testes de unidade são a chave para escrever códigos de maneira eficiente e confiável, criando um ambiente de programação de excelência. 

Em resumo, o TDD é uma prática que encoraja a escrita de testes unitários antes de escrever o código de produção. Isso garante que o código seja testável e confiável desde o início. Frameworks de teste, como o pytest para Python ou o JUnit para Java, simplificam a criação de testes unitários.

Design SOLID 

O princípio SOLID (Single Responsibility, Open-Closed, Liskov Substitution, Interface Segregation, Dependency Inversion) é uma parte essencial do Clean Code e é uma abordagem que visa à criação de softwares robustos e de fácil manutenção.

Adicionalmente, estabelece diretrizes fundamentais para criar código limpo e extensível. Enfatizando a separação de responsabilidades, a abertura para extensões e o fechamento para modificações.

O SOLID design em Clean Code destaca a necessidade de se criar classes e módulos que tenham responsabilidades bem definidas, evitando que façam muitas coisas diferentes. Gerando um código mais organizado, fácil de entender e de manter.

Além disso, o princípio do "aberto/fechado" enfatiza que o código deve estar aberto para extensões, e fechado para modificações, o que significa que alterações em uma parte do sistema não devem exigir a modificação de outras partes.

Seguindo esses princípios, os desenvolvedores criam sistemas menos propensos a erros, mais flexíveis e prontos para se adaptarem às mudanças. O SOLID design é, portanto, um dos pilares do Clean Code, contribuindo significativamente para a qualidade e a longevidade do software.

Continuous Integration and Delivery (CI/CD)

A integração contínua (CI) e a entrega contínua (CD) automatizam o processo de teste, construção e implantação do código, garantindo que as alterações sejam verificadas regularmente e implementadas eficientemente, reduzindo o risco de problemas de integração.

Primeiramente, abordaremos sobre a Integração Contínua (CI) que é um processo pelo qual as alterações de código são integradas frequentemente em um repositório compartilhado. 

O sistema de CI automatizado executa testes e verificações a cada modificação, garantindo que o código seja compatível com os padrões de qualidade e que não tenha introduzido erros.

No caso de ocorrer algum problema, a equipe é imediatamente notificada, permitindo a rápida correção desse contratempo, algo de crucial importância para o Clean Code, pois ajuda a identificar problemas de forma precoce, incentivando a escrita de código limpo desde o início. 

Em segundo lugar, versaremos sobre a Entrega Contínua (CD) que dá continuidade à CI, envolvendo a automação do processo de implantação, de modo que o software esteja sempre pronto para ser implantado em produção. 

Com a CD, o código é construído, testado e implantado em um ambiente de produção tempestivamente, sem intervenção manual, garantindo que o software seja confiável, pronto para o uso e mantendo a manutenção de código limpo, permitindo a entrega de softwares de alta qualidade.

Em síntese, a Integração Contínua e a Entrega Contínua são práticas substanciais no âmbito do Clean Code, sendo ambas a base de uma abordagem de desenvolvimento que valoriza a qualidade e a excelência na programação.

Refatoração de Código (Code Refactoring)

A refatoração é o processo de aprimorar a estrutura e a legibilidade do código sem alterar sua funcionalidade e seu comportamento externo, ajudando a manter o código limpo ao longo do tempo, tornando-o mais fácil de entender e manter. 

Este processo é de suma importância devido às constantes mudanças que os softwares estão suscetíveis durante o período de desenvolvimento, permitindo que o código se adeque a essas mudanças de maneira flexível, garantindo que o programa permaneça robusto e de fácil manutenção ao longo do tempo.

Padrões de Nomes de Variáveis (Naming Conventions)

Padrões de nomenclatura são vitais para garantir que as variáveis tenham nomes significativos e sejam consistentes em todo o código. Por exemplo, em Python, é comum usar o "snake_case" para nomes de variáveis, enquanto em Java, o "camelCase" é mais prevalente.

Conclusão

Em resumo, o Clean Code é uma abordagem basilar para desenvolver softwares de qualidade. Ao seguir os princípios, aplicar as práticas e utilizar as ferramentas adequadas, podemos criar códigos limpos. Portanto, explore o mundo do Clean Code e eleve sua programação a um novo patamar de excelência.

Referências

https://dev.to/alexomeyer/10-must-know-patterns-for-writing-clean-code-with-python-56bf

https://dev.to/favourmark05/writing-clean-code-best-practices-and-principles-3amh

https://blog.cod3r.com.br/organizacao-e-padronizacao-com-eslint/

https://escolapython.viniciusmunhoz.com/curso/21.html

https://testsigma.com/blog/clean-coding-for-testers/

https://www.devmedia.com.br/java-com-checkstyle/26043