Backend

Introdução ao Clean Code

Clean Code, ou código limpo, é uma filosofia de desenvolvimento de software que tem como foco a facilidade para escrever, ler e manter o código.

Fruto de muitos anos de experiência e problemas passados, Robert C. Martin – carinhosamente conhecido como Uncle Bob – nos agraciou com seu livro “Clean Code: A Handbook of Agile Software Craftsmanship”, onde fez algumas constatações que são simples, ao mesmo tempo incríveis, e abrem portas para um novo mundo de desenvolvimento ao serem compreendidas.

Um dos primeiros pontos que é apresentado se refere a proporção de leitura para escrita de código, que, de acordo com Uncle Bob, é de 10:1. Isso significa que, como desenvolvedores, vamos passar aproximadamente 90% do nosso tempo lendo código e apenas 10% escrevendo efetivamente. Portanto, um código bem escrito que facilite a leitura não é apenas desejável, mas necessário, para que possamos garantir velocidade na evolução do software, bem como nas correções de bugs.

Por vezes, podemos cair em tentação de pensar que um software está completo com uma nova funcionalidade recém desenvolvida, mas a verdade é que softwares nunca estão completamente finalizados. Trabalhamos para resolver problemas de negócio, e estes problemas precisam constantemente de atualizações e lançamentos de novas features.

Ao aceitarmos esta realidade, de que um software jamais estará pronto e sempre sofrerá alterações, começamos a entender a necessidade de escrever um código limpo. Se escrevermos código apenas para resolver o problema e não o mantivermos limpo, com o tempo teremos grandes dificuldades para manutenção e evolução, até que chegaremos em um momento onde uma escolha será feita: é mais simples começar um software do zero, do que prosseguir com um código ruim.

Reconheceu este cenário? Tenho certeza que todos nós já passamos por isso.

Então como evitar? 

Best Heres Johnny GIFs | Gfycat

“Always code as if the person who ends up maintaining your code is a violent psychopath who knows where you live.”

O livro “Clean Code: A Handbook of Agile Software Craftsmanship” é fantástico e possui bastante conteúdo. Recomendamos fortemente que seja lido por todo profissional de software. Possui muito conteúdo e muitos exemplos, na prática, de como construir e manter um código limpo. Por agora, vamos apenas arranhar a superfície do tema. Como o título sugere, este texto é uma breve introdução.

Nomes são importantes… muito importantes

Bryan Cranston GIF by Breaking Bad - Find & Share on GIPHY

Uma das maiores dificuldades quando escrevemos código é escolher um bom nome. Um bom nome é aquele que transmite o significado da existência daquele trecho de código, de acordo com suas características. Para garantirmos um código limpo, precisamos garantir que nomes adequados serão dados a variáveis, funções, parâmetros, classes ou métodos, sempre de acordo com as funcionalidades desempenhadas por cada um.

Pontos importantes:

  • Seja preciso: é necessário transmitir a ideia principal daquilo que está sendo nomeado. Para isso, procure utilizar os conceitos do domínio do software. Mas lembre-se de não dar voltas, seja conciso e direto.
  • Não tenha medo de nomes grandes: nomes precisam ser expressivos, sua maior responsabilidade é fazer o leitor compreender sobre o que se trata aquela variável, por exemplo. Não tenha medo de escrever nomes grandes, independente do que esteja sendo nomeado. É melhor ter um nome grande que carrega significado do que um nome curto que nada signifique.
  • Para Métodos ou Funções: devem ter nomes de verbos, devem ser expressos como ações, por que afinal de contas… são ações! Desta forma conseguiremos expressar a finalidade de um método.
  • Para Classes e Objetos: devemos utilizar substantivos!

Em resumo, devemos procurar expressar com clareza os significados daquilo que estamos nomeando, além de utilizar nomes relacionados com o domínio da nossa solução! E não tenha medo de nomes grandes!

Funções devem ser pequenas

Neste ponto, Uncle bob nos traz uma visão simples de compreender.

A primeira regra sobre funções é:

“Elas devem ser pequenas”.

E a segunda regra é:

“Devem ser menores ainda”.

O que está por trás destas duas simples regras é o seguinte: funções devem cumprir uma – e apenas uma – única tarefa, cumprindo-a da maneira mais simples possível. Isso abre algumas portas para que possamos reutilizar aquela função diversas vezes no código, facilitando a manutenção do mesmo. 

Comente apenas o que precisa ser comentado

Comentários são controversos. Muito utilizados para indicar o que está sendo feito, podemos facilmente cair na armadilha de achar que comentários nos ajudam a entender e compreender melhor sobre o código. Afinal, não é este o objetivo do Clean Code?

Contudo, o código está constantemente sendo alterado enquanto os comentários não costumam acompanhar na mesma velocidade. Acontece que, com o tempo, colecionamos comentários que não fazem mais sentido, além de poluir a visão e esconder um problema maior: se precisamos escrever tantos comentários para explicar o que nosso código faz, então nosso código não está limpo.

Se observamos com atenção os pontos citados anteriormente, garantindo uma nomenclatura adequada a métodos, classes e objetos, além de métodos pequenos e especializados em uma ação, nosso código não precisa de comentários, pois a escrita do código está nos contando uma história, uma sequência de ações, passos a serem executados. 

Ou seja, o nosso código é uma documentação orgânica e não precisa de explicações extras.

Isso significa que comentários são proibidos? Claro que não! Comentários existem por uma razão, quando não temos outra forma de deixar claro o motivo pelo qual aquilo que está escrito no código existente, podemos sim utilizar comentários para nos auxiliar. Mas sempre com bastante atenção e tomando cuidado para não criarmos armadilhas que vão nos dar falsas pistas sobre o comportamento do nosso código no futuro.

DRY – Don’t Repeat Yourself!

Homem-Aranha apontando para o Homem-Aranha: a origem do meme - Dicionário  Popular

DRY é o acrônimo para Don’t Repeat Yourself (tradução: não repita a si mesmo). É um conceito que define que cada parte de conhecimento do domínio do sistema deve possuir apenas uma única representação, evitando assim, a ambiguidade do código. Em resumo, não devemos permitir que duas partes do programa que possuem a mesma função existam. Por vezes passamos por estas situações quando usamos o famigerado “copiar e colar”.

O motivo pelo qual devemos evitar repetições é a complexidade que podemos trazer na hora da manutenção do código. Imagine que tenhamos em mãos dois métodos que façam um cálculo de salário, com pequenas diferenças: em um deles calculamos, além do salário líquido, o FGTS provisionado e, no outro, calculamos férias proporcionais daquele mês. Se por qualquer motivo que seja, a forma de cálculo do salário for alterada, precisaremos modificar a mesma regra em dois pontos diferentes. Com o tempo, a quantidade de ambiguidades e repetições podem tomar muito tempo de desenvolvimento adicionando complexidade no nosso código. Portanto, evite duplicações!

Exceptions – o seguro morreu de velho

Meme Creator - Funny no exceptions! Meme Generator at MemeCreator.org!

Por mais perfeito que possamos pensar que seja, eventualmente nosso código vai se deparar com algum erro, seja de negócio ou de infraestrutura. Isso é normal e não devemos arrancar nossos cabelos quando ocorre. Vamos aceitar a realidade, não existe software infalível.

O que devemos fazer é garantir que estamos prevendo, com o máximo de informações que temos no momento, o tratamento de possíveis erros e exceções.

Hoje em dia temos a disposição linguagens que possuem recursos para tratar erros nos códigos através de Exceptions e blocos try-catch:

  • Exceptions: mecanismo que sinaliza eventos excepcionais. Por exemplo, tentar inserir o caractere “a” em uma variável do tipo inteiro.
  • Blocos try-catch: capturam as exceções citadas. Portanto, devem ser utilizados de maneira global. Afinal de contas, os métodos já possuem suas funções (que não é tratar erros).

Regra do Escoteiro

Boys Scouts GIFs - Get the best GIF on GIPHY


Escoteiros possuem uma regra, e não, não estamos falando do lema “sempre alerta”. A regra em questão é deixar o acampamento mais limpo do que você o encontrou. No nosso caso podemos adaptar para: “deixe o código mais limpo do que estava antes de você mexer nele”.

Refatorar o código deve ser um hábito, pois é uma atividade essencial para a modernização do software e deve ser feita com bastante cuidado para não impactar o sistema que já está rodando.

Devemos evitar pensamentos como “isso é perda de tempo” ou “se tá funcionando, melhor não mexer em nada”, pois são prejudiciais a longo prazo. O melhor momento para refatorar o código é assim que terminamos de desenvolver! Quanto antes, melhor, pois a lógica está fresca na cabeça ainda.

Porém, não podemos esquecer que refatorar um código é uma atividade que deve ser feita com bastante cuidado! Por mais que seja necessária, deve ser feita com atenção para não gerarmos novos bugs.

Mantenha seus testes limpos

Tidy GIFs - Get the best GIF on GIPHY

Só podemos chamar nosso código de limpo se ele for validado. Testes são de extrema importância e precisamos garantir que nosso código possui a cobertura adequada, além de garantir que os testes escritos sejam mantidos como código limpo também!

Testes limpos seguem as regras do acrônimo FIRST – Fast, Independent, Repeatable, Self-validation, Timely.

  • Rapidez: testes devem ser rápidos, para que possam ser executados diversas vezes
  • Independência: quando testes são dependentes, uma falha pode causar um efeito dominó, dificultando a análise individual
  • Repetitividade: deve ser possível repetir o teste em qualquer ambiente
  • Auto validação: bons testes possuem como resultado respostas do tipo “verdadeiro” ou “falso”. Caso contrário, a falha pode se tornar subjetiva
  • Pontualidade: os testes precisam ser escritos antes do código de produção, onde os testes serão aplicados. Caso contrário, o código pode ficar complexo demais para ser testado ou até pode ser que o código não possa ser testado

Dê valor e importância ao seu código!

Nesta breve introdução, vimos diversos conceitos utilizados e aprofundados no livro “Clean Code: A Handbook of Agile Software Craftsmanship“. Recomendamos fortemente que todos leiam este livro. É uma leitura muito leve, divertida e temos certeza que acrescentará bastante a todo profissional de desenvolvimento de software.

Se pudéssemos escolher uma frase para sintetizar o que é Clean Code podemos dizer que:

Um código limpo sempre parece que foi escrito por alguém que se importava.” – Michael Feathers

Conclusão

Dar importância ao código é:

  • Escolher bons nomes
  • Criar funções pequenas e específicas
  • Não se repita e não seja redundante
  • Esteja sempre atento a possíveis erros
  • Refatorar o código, sempre
  • Manter os testes limpos para as validações

No final das contas, a sensação de orgulho virá naturalmente e será recompensadora!

Referências:

%d blogueiros gostam disto: