Seu código é um desastre! 7 erros comuns na programação e como evitá-los com Clean Code
- #Arquitetura de Sistemas
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:
- Nomes de variáveis e funções não descritivas.
- Código duplicado.
- Funções e classes muito longas.
- Não seguir um padrão de codificação consistente.
- Falta de comentários ou comentários desnecessários.
- Uso excessivo de condicionais aninhados.
- 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).
