Código legível para Humanos: Conheça as boas práticas do Clean Code

“Qualquer um consegue escrever código que um computador entende. Bons programadores escrevem código que humanos entendem.” - Martin Fowler.

Introdução

Já foi comprovado que programar utilizando o paradigma “Orientado à gambiarras” não é algo muito viável, e muito menos lucrativo a médio/longo prazo para nenhuma aplicação. Desenvolver qualquer aplicação vai muito mais além de simplesmente colocar o programa para funcionar, entregá-lo e deixar por isso mesmo, e isso é um erro que muitos programadores iniciantes cometem. A verdade é que, na maior parte de nosso tempo, estaremos trabalhando na manutenção de sistemas desenvolvidos, que já estão rodando e sendo utilizado por usuários.

Ter um código limpo é ter um código manutenível, legível, e que seja possível de ser testado. Para isso, o Clean Code, ou Código Limpo, para quem gosta do bom Português, traz princípios e regras que são fundamentais para aplicação de seus conceitos na prática, e é isso que esse artigo pretende trazer da forma mais clara e resumida possível.

Conceituando Clean Code

O Clean Code traz consigo a filosofia de aplicação de escrita de códigos que sejam de fácil leitura, bom entendimento, de técnica simples de aplicação, e melhor manutenibilidade. A verdade é que um sistema desenvolvido nunca estará desenvolvido por completo, sempre existirá a necessidade de atualizações, aplicação de novas funcionalidades, o código em si, com o passar do tempo “envelhece”.

Podemos contextualizar a técnica do “Código limpo” com 3 características principais que as nossas diversas linhas de código devem seguir:

Légivel: um código de fácil entendimento, que seja semântico, coeso, facilita a leitura, logo sua compreensão fica mais rápida e intuitiva;
Testável: toda aplicação deve sempre passar por testes, nos mais diversos cenários, para termos segurança em alterá-los, quando necessário, sem medo de causar, até mesmo, um “crash” no sistema;
Fácil de ser mantido: deve ser passível de alteração, corroborando com o item acima, possibilitar a adição de novas funcionalidades, sem necessidade de uma refatoração geral, tratando os possíveis erros, eventualmente, em tempo de execução.

Princípios e boas práticas para se obter um Código Limpo

Nomes são muito importantes

Variáveis, funções, métodos, classes, objetos. Nomeá-los de forma descritiva auxilia no entendimento do que aquela variável deve armazenar, o que aquela determinada classe representa, e quais o comportamentos deve ter.

Exemplo sem boas práticas:

public class ContaDoBanco {
  
  String n;
  String documento;
  int i;
  double dinheiro;

  void saque(double dinheiro){
      this.dinheiro = this.dinheiro - dinheiro;
  }

  void deposito(double dinheiro){
      this.dinheiro = this.dinheiro + dinheiro;
  }
  
}

Exemplo com boas práticas:

public class Conta{
  final private Pessoa titular;
  private double saldo;

  void sacar(double valor){
      this.saldo -= valor;
  }

  void depositar(double valor){
      this.saldo += valor;
  }
}

Regra do Escoteiro

Se for mexer no código, deixe ainda mais limpo do que quando encontrou. Imagine que você criou uma classe que representa uma conta bancária, como exemplo anterior, e de repente alguém vai no código, altera deixando ele bem bagunçado e desorganizado. De certa forma, além se tratar de um sistema de suma importância, também se trata de uma questão ética, e entender os princípios de programar de forma “limpa”. Lembre-se, não estamos programando sozinhos, alguém vai estar lendo o seu código, e é bom garantir que tanto a aplicação quanto os demais desenvolvedores fiquem pacíficos.

KISS

“I gotta tell you what I'm feeling inside, I could lie to myself, but it's true 🎵 “.

Não, não se trata da banda KISS.

KISS, nesse caso, é a sigla para “Keep it Stupid Simple”, e em outras palavras, mantenha o código “estupidamente” simples. Criar funções simples, claras e pequenas é determinante para manter a legibilidade do código. Porém, é necessário ponderar. Muitas vezes será necessário escrever o nome de um método de uma forma um pouco mais extensa para descrever bem o propósito para que foi criado.

public class Compra{
  List<Produto> listaDeProdutos = new ArrayList<>();
  
  void adicionarProdutoAoCarrinho(Produto produto){

  }
}

DRY (Don’t Repeat Yourself)

“Não repita a si mesmo.” - The Pragmatic Programmer.

É interessante que na aplicação seja evitada ambiguidades, ou o famoso CTRL + C e CTRL + V, por mais tentador que seja. Importante criar código com conceitos e conhecimentos reutilizáveis de modo que seja mais contextual e coeso.

Comente apenas o necessário

O ideal é que seus métodos e funções, variáveis, atributos, etc., sejam autoexplicativos, sem a necessidade de um comentário acima explicando o que aquele trecho do código está fazendo.

Costumando modificar os códigos constantemente, porém os comentários são ignorados pela linguagem, seja ela qual for, não sejam linhas executáveis, e com isso o programador pode acabar ignorando também, e deixando aquele comentário desnecessário no código.

Com comentários:

public class Compra{
  List<Produto> listaDeProdutos = new ArrayList<>();
  
  void adicionar(Produto produto){
      /**
      Esse método tem como função adicionar os produtos no carrinho
      de compras
      */
  }
}

Sem comentários, de forma mais limpa:

public class Compra{
  List<Produto> listaDeProdutos = new ArrayList<>();
  
  void adicionarProdutoAoCarrinho(Produto produto){

  }
}

Tratamento de erros

Segundo Michael Feathers, mentor e autor, os programadores têm que garantir que o código continuará fazendo o que for necessário para que o sistema continue a funcionar, mesmo quando as coisas derem errado. Por isso, é importante saber tratar exceções de forma correta e evitar que a aplicação pare de funcionar de repente.

public class erroDiv{
  public static void main(String [] args){
      try{
          int a = 0;
          int b = 10 / a;
      } catch (ArithmeticException e){
              System.out.println("Divisão por zero");
          }
  }
}

Testes limpos

Todo código limpo é validado, passou por testes, foi avaliado criteriosamente. Esses testes, para serem limpos deve seguir algumas regras:

Deve ser rápido, assim poderão ser realizado vários testes simultâneos, e vários cenários possíveis, tornando eficiente e dinâmico;
Deve ser independente, de baixo acoplamento, facilitando a análise do que está acontecendo;
Repetível, como dito anteriormente, deve ser realizado vários testes, e em vários cenários e ambientes diferentes;
Auto-validação, os testes devem retornar valores booleanos, true ou false, para que a falha não seja implícita e evaziva;
Timely, seguindo o critério da pontualidade, o testes, de forma ideal, podem ser descritos antes do próprio código, para evitar que, futuramente, a complexidade do código aumente demasiadamente, impossibilitando a realização dos testes.

Conclusão

De fato, para quem está muito iniciante na programação, seja em qual linguagem for, tentar entender mais a fundo sobre os conceitos do Clean Code pode não ser interessante no momento. Mas, é inevitável que todo desenvolvedor use hoje em dia. Quanto mais aplicações organizadas tivermos, menos tempo perderemos analisando código, e refatorando. Claro, não podemos evitar que ainda existem sistemas antigos, legados, e com sua estrutura mais difícil de ser mexida.

Sem dúvida, o Clean Code veio para nos ajudar a limpar a bagunça, e arrumar a casa, para que tudo continue funcionando bem, legível, elegante e coeso.

Pontos importantes:

Siga as convenções (padrões de projeto) de determinada a aplicação que esteja entrando para participar. É muito mais fácil entrar numa empresa, ou projeto, que já esteja em produção, então é necessário se adaptar ao padrão adotado pelo projeto, ou empresa. Não é muito recomendável que hajam vários padrões de projeto(pastas, arquivos, interfaces, etc..) num mesmo projeto.
Resolva os bugs! Pode ser tentador resolver apenas um bug e deixar o resto para depois, porém resolvê-los logo de uma só vez pode prevenir que surjam novos bugs, e a complexidade aumentar de forma significativa.
Programar Orientado a Objetos consiste muito na reutilização de código, como Herança e Polimorfismo, sendo um diferencial para quem deseja uma arquitetura limpa no seu código.

Referências

Clean code: o que é, Casos de Uso, Exemplo de Código

Conheça os princípios do Clean Code

Clean code: guia e exemplos

Código limpo: dicas práticas para turbinar a escrita, leitura, e escalabilidade de um código