Seu código é um desastre! 7 erros comuns na programação e como evitá-los com Clean Code

Já escreveu um código e no dia seguinte não fazia mais ideia de como ele funcionava? Ou pior: em um projeto colaborativo achou um código terrível e se perguntou quem escreveu essa bagunça, mas, quando foi ver na timeline, foi você o responsável?

Seu código ter muitas linhas e estar funcionando como o esperado, não necessariamente é um sinal de virtude. Seu script deve sempre estar evoluindo, mas certos hábitos podem comprometer (e muito!) seu projeto no longo prazo.

A filosofia do Clean Code, proposta por Robert C. Martin (também conhecido como uncle Bob), surge como uma solução para muitos desses problemas. Vamos explorar sete erros comuns na programação e como o Clean Code pode ajudar a evitá-los. Porém, para já matar sua curiosidade, segue a lista:

1. Nomes de variáveis e funções não descritivas.
2. Código duplicado.
3. Funções e classes muito longas.
4. Não seguir um padrão de codificação consistente.
5. Falta de comentários ou comentários desnecessários.
6. Uso excessivo de condicionais aninhados.
7. Falta de testes unitários.

Nomeando com precisão usando Clean Code

Sabe aquele momento em que você olha para um trecho de código e pensa: "O que esse trecho faz"? Muitas vezes, a confusão surge devido a nomes de variáveis e funções que não são claros.

Utilizar nomes genéricos como "x", "y", "a", "b", "num", "let" ou "procDat()" pode parecer conveniente no início, mas pode levar a dores de cabeça no futuro.

Clean Code nos ensina a ser mais expressivos em nossa nomeação. Variáveis devem descrever com precisão o que armazenam e funções devem claramente indicar sua ação.

Por exemplo, em vez de usar "d" para uma data, por que não "dataDeNascimento"? Ou em vez de "calc()", que tal "calcularSalarioLiquido()"?

A regra é simples: se alguém, mesmo que não tenha escrito o código, puder entender sua função apenas pelo nome, você está no caminho certo. Afinal, um bom código deve ser autoexplicativo.

Nomear com precisão não só torna o código mais legível, mas também facilita a manutenção e colaboração entre desenvolvedores.

Clean Code e a fuga da redundância

Código duplicado é frequentemente visto como o grande pecado da programação. Copiar e colar trechos de código em diversos pontos cria armadilhas para o dev. A manutenção se torna árdua, já que mudanças em uma parte exigem correções em outras. Isso abre portas para erros e inconsistências.

A abordagem do Clean Code traz soluções para esse dilema. A refatoração, por exemplo, permite reestruturar o código sem mudar sua função. Criar métodos e funções evita repetições desnecessárias.

O princípio DRY (Don't Repeat Yourself) é um guia nessa jornada. Ele preconiza que cada informação deve existir em um único lugar no sistema. Ao seguir esse princípio, o software se torna mais flexível e fácil de manter.

Veja um código como exemplo escrito em python:

# Código original com repetição
resultado1 = 5 + 3
resultado2 = 12 + 7
resultado3 = 8 + 2


# Refatoração com função
def adicionar(a, b):
  return a + b


resultado1 = adicionar(5, 3)
resultado2 = adicionar(12, 7)
resultado3 = adicionar(8, 2)

Simplificando Estruturas com Clean Code

Já se deparou com uma função ou classe que parece mais um post? Aquelas que você rola a tela infinitamente e se perde no meio do caminho. E pior! Se comporta como um ganso: nem voa bem, nem nada bem, nem anda bem. Esse é o drama das funções e classes longas.

Por exemplo, imagine uma função que, além de calcular o salário de um empregado, também gera relatórios, envia e-mails, gera uma imagem, toca um sino, etc. Confusão, né? E se eu quiser só que a imagem seja gerada?

Clean Code vem para resolver isso. A ideia é ter funções e classes que fazem uma coisa só e fazem bem feito. Em vez de uma mega função, poderíamos ter várias: calcularSalario(), gerarRelatorio(), enviarEmail(), gerarImagem(), tocarSino(), etc. Cada uma focada em sua tarefa.

Veja o código como exemplo em javascript:

// Código antes da refatoração
function megaFuncao(salarioBase) {
  let salario = salarioBase + 500;  // Calcula salário
  console.log('Relatório gerado');  // Gera relatório
  console.log('E-mail enviado');    // Envia e-mail
  console.log('Imagem gerada');     // Gera imagem
  console.log('Sino tocado');       // Toca sino
  return salario;
}


// Código refatorado conforme os princípios do Clean Code
function calcularSalario(salarioBase) {
  return salarioBase + 500;
}


function gerarRelatorio() {
  console.log('Relatório gerado');
}


function enviarEmail() {
  console.log('E-mail enviado');
}


function gerarImagem() {
  console.log('Imagem gerada');
}


function tocarSino() {
  console.log('Sino tocado');
}


// Agora cada função pode ser chamada individualmente conforme a necessidade
let salario = calcularSalario(3000);
gerarRelatorio();
enviarEmail();
gerarImagem();
tocarSino();

Ao adotar essa prática, seu código se torna mais legível, fácil de manter e, sobretudo, mais eficiente porque o código se torna mais modularizado. Troque o ganso por uma águia, um cavalo e um peixe!

Lembre-se: no mundo da programação, menos é mais. E com Clean Code, você tira o excesso, mantém a essência e foge da função ganso.

Consistência e Clean Code: um casamento necessário

Já imaginou ler um livro que alterna entre formalidades e gírias a cada parágrafo? Seria uma bagunça! O mesmo ocorre quando não seguimos um padrão de codificação no desenvolvimento de software.

Imagine uma função nomeada calcularSomaTotal e outra como calcMed (para calcular média). É como misturar Shakespeare com este que vos escreve.

Clean Code nos ensina que a consistência é a chave. Escolher um padrão e aderir a ele torna tudo mais legível e fácil de manter. Observe o exemplo escrito em java:

// Código antes da refatoração
public class Calculadora {
  public int calcularSomaTotal(int[] numeros) {
      int soma = 0;
      for (int numero : numeros) {
          soma += numero;
      }
      return soma;
  }


  public float calcMed(int[] num) {
      if (num.length == 0) return 0;
      return (float) calcularSomaTotal(num) / num.length;
  }
}


// Código refatorado conforme os princípios do Clean Code
public class CalculadoraRefatorada {
  public int calcularSomaTotal(int[] numeros) {
      int soma = 0;
      for (int numero : numeros) {
          soma += numero;
      }
      return soma;
  }


  public float calcularMedia(int[] numeros) {
      if (numeros.length == 0) return 0;
      return (float) calcularSomaTotal(numeros) / numeros.length;
  }
}

Então, da próxima vez que você pensar em nomear aquela variável de uma forma encurtada ou usar abreviações obscuras, lembre-se: a consistência é sua amiga. E, assim como em qualquer bom relacionamento, ela exige compromisso.

Delicada arte de comentar com Clean Code

Comentários no código são como temperos na culinária: na quantidade certa, são perfeitos; em excesso, podem arruinar o prato.

Por exemplo, se você tem uma função chamada "calcular_salario()" (em python se usa snake_case para nome de funções), um comentário como "Esta função calcula o salário" é totalmente redundante.

Por outro lado, sem comentários, algumas partes do código podem parecer misteriosas. Imagine uma fórmula matemática complexa sem nenhuma explicação. Ficaria difícil entender, certo?

A solução do Clean Code é simples: o código deve ser autoexplicativo sempre que possível. Se uma função faz exatamente o que seu nome diz, comentários adicionais são desnecessários.

Exemplo (errado) de comentário redundante:
def calcular_salario(horas_trabalhadas, valor_por_hora):
  # Calcula o salário baseado nas horas trabalhadas e no valor por hora
  return horas_trabalhadas * valor_por_hora

Exemplo de função sem comentário pois é autoexplicativo:
def calcular_desconto(preco_original):
  TAXA_DESCONTO = 0.08  
  return preco_original * TAXA_DESCONTO

Exemplo de comentário bem colocado visto que o nome da função não a descreve (propositalmente) bem: 
def formula_misteriosa(x, y):
  # A fórmula a seguir é baseada no Teorema de Pitágoras, onde c é a hipotenusa
  c = ((x**2 + y**2)**0.5)
  return c

Contudo, quando comentários são realmente necessários, eles devem ser claros e diretos, esclarecendo a intenção do código e não apenas o que ele faz.

Evitando o labirinto de Condicionais com Clean Code

Você já se deparou com um código cheio de "ifs" dentro de "ifs"? Isso é o que chamamos de condicionais aninhados, e eles podem transformar seu código em um verdadeiro labirinto.

Imagine uma situação em que você está validando um formulário. Se o nome do usuário não estiver vazio e a senha tiver mais de 8 caracteres e o e-mail for válido, então faça algo. A solução Clean Code? Simplifique! Separe as validações em funções menores e dê a elas nomes descritivos.

Para entender, veja o código em javascript:

// Código antes da refatoração
function validarFormulario(nome, senha, email) {
  if (nome !== "") {
      if (senha.length > 8) {
          if (email.includes("@")) {
              console.log("Formulário válido");
          }
      }
  }
}


// Código refatorado conforme os princípios do Clean Code
function validarNome(nome) {
  return nome !== "";
}


function senhaForte(senha) {
  return senha.length > 8;
}


function emailValido(email) {
  return email.includes("@");
}


function validarFormulario(nome, senha, email) {
  if (validarNome(nome) && senhaForte(senha) && emailValido(email)) {
      console.log("Formulário válido");
  }
}

Em resumo, não seja como o Zoro (tadinho): pegue o caminho fácil do Clean Code e evite se perder no labirinto de "ifs".

Testes são a alma do Clean Code

Já imaginou preparar um prato sem provar nada até o final? Programar sem testes é assim: um mistério até o prato ser servido! Testes unitários são como aquela prova de sabores no meio do processo, garantindo que cada etapa está deliciosa e correta.

Imagine criar uma função que calcula o desconto em uma loja. Sem testes, você só descobre falhas quando o cliente reclama. Mas, com um teste unitário, você verifica antecipadamente se a função aplica o desconto corretamente.

Mais ainda: os testes são fundamentais na hora de refatorar um código pois os testes indicaram inconsistência a serem corrigidas.

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;


public class Loja {


  public double aplicarDesconto(double precoOriginal, double descontoPercentual) {
      return precoOriginal - (precoOriginal * descontoPercentual / 100);
  }


  @Test
  void testeAplicarDesconto() {
      Loja loja = new Loja();
      assertEquals(90, loja.aplicarDesconto(100, 10));
      assertEquals(80, loja.aplicarDesconto(100, 20));
      assertEquals(70, loja.aplicarDesconto(100, 30));
  }
}

A filosofia do Clean Code vai além de escrever códigos legíveis. Ela preza pela confiança no código. E como confiar sem testar? Portanto, lembre-se: um código limpo tem testes claros, diretos e eficazes. Eles são a alma do seu programa!

Conclusão: Clean Code reduzindo o caos do seu código

Sabe quando guardamos algo no quarto e, semanas depois, não encontramos mais nada? Código bagunçado é assim: a gente perde aquilo que importa!

Clean Code não é só uma "moda" de programador, é como um GPS para o seu projeto. Ele não apenas evita que você tropece nos próprios pés, mas garante que, daqui a anos, qualquer pessoa (ou você mesmo depois de umas férias!) consiga entender e trabalhar nele sem querer puxar os cabelos.

Quer um código saudável e que resista ao tempo? Siga o conselho do Uncle Bob: Invista em Clean Code! Seu futuro eu agradecerá!

Referências para o artigo e onde ler mais sobre Clean Code

• Clean Code - Guia e Exemplos (DEV Community): Este guia oferece uma explicação sobre o que é código limpo e por que é importante, além de fornecer exemplos práticos para ilustrar os princípios de código limpo​​. Você pode ver o artigo completo aqui.
• Conheça os 7 princípios do Clean Code (HostGator Brasil): Este artigo apresenta os 7 princípios do Clean Code, uma técnica que surgiu no final da década de 2000 com o objetivo de simplificar a escrita e a leitura de códigos de programação​​. Você pode ver o artigo completo aqui.
• Clean code: o que é, porque usar e principais regras! (Blog da Trybe): O artigo discute a origem do Clean Code, seus benefícios, e apresenta as 25 principais regras para escrever código limpo, além de um exemplo prático​​. Você pode ver o artigo completo aqui.
• Clean Code: O que é, Casos de Uso, Exemplo de Código Limpo (Alura): Este artigo discute o design de código e Clean Code, e oferece exemplos práticos de código limpo​​. Você pode ver o artigo completo aqui.
• Como Escrever Código Limpo - Dicas e Melhores Práticas (Manual Completo) (FreeCodeCamp): Este artigo oferece uma variedade de formas de avaliar código limpo, como boa documentação, formatação consistente, uma base de código bem organizada, revisões de código e testes​. Você pode acessar o artigo completo aqui​​ (em inglês).
• Clean Code Explained – A Practical Introduction to Clean Coding (FreeCodeCamp): Este post introduz as principais princípios para melhorar a qualidade do código com exemplos, baseando-se principalmente no livro "Clean Code" de Robert J. Martin​. Você pode acessar o artigo completo aqui (em inglês)
• 10 Dicas para Escrever Código Limpo (Pluralsight): Este artigo menciona que o código limpo é focado no leitor e produz software fácil de escrever, ler e manter, destacando a importância de produzir código limpo como uma habilidade essencial para desenvolvedores de software. Você pode acessar o artigo completo aqui​​ (em inglês).
• Como Praticar Código Limpo em Projetos de Software (DZone): Este artigo discute o termo Clean Code usado no livro de Robert C. Martin e a importância de escrever o código fonte de maneira "limpa" e também documentar​. Você pode acessar o artigo completo aqui​​ (em inglês).
• 12 Convenções para Escrever Código Limpo (Better Programming): Este artigo fala sobre a simplicidade e direção do código limpo, que lê como prosa bem escrita, cheia de abstrações nítidas e linhas de controle diretas, conforme descrito por Robert C. Martin​​. Você pode acessar o artigo completo aqui​​ (em inglês).