Todo programador já parou por alguns segundos depois de entregar um trabalho e pensou que seu código poderia estar mais bem feito. Um código de alta qualidade conquista clientes, usuários e quebra barreiras. Mas o que significa escrever um código de alta qualidade? Para nós, significa que seu código:

 

  • Pode ser lido e entendido de uma vez só;
  • Contém erros mínimos;
  • Segue os padrões da linguagem em que está escrito
  • Faz o que você espera e tem uma prova do seu sucesso.

 

Agora que sabemos o que pretendemos, precisamos aprender a escrever código limpo. Mas como se faz isso? 

 

Treinando. Muitos dos seus códigos não serão os melhores, mas eles sempre te ajudarão a aprender como se tornar melhor. A seguir está uma lista de dicas e truques que compilamos para te ajudar a melhorar a qualidade do seu código a partir do próximo trabalho.

 

1. Use um Linter

 

Tantos problemas podem ser resolvidos usando um código linter. Para quem não está familiarizado com linters, um linter de código lê seu código, gerando erros e avisos se seu código não estiver em conformidade com as especificações e os padrões de um idioma. Esses avisos podem parecer insignificantes, mas eles aumentam com o tempo. Para tirar o máximo proveito do uso de um linter, sugiro os seguintes truques:

 

Aplicar o idioma ou o padrão de estrutura

 

Execute um linter no seu código para impor o conjunto mais amplamente aceito de padrões para a linguagem ou framework em que você está trabalhando. Por exemplo, se você está escrevendo Python, use o pacote pylint, que reforça regras definidas no PEP-8. Se você estiver escrevendo um aplicativo Angular, use uma configuração de linter que siga o guia de estilo Angular.

 

Integre seu Linter com CI

 

Um linter realmente não vai ajudá-lo a menos que você o use regularmente. Leva apenas alguns minutos para aprender a usar um linter corretamente, então por que tantos desenvolvedores negligenciam fazer isso? Talvez seja porque estamos frequentemente confiantes em nosso código e odiamos adicionar etapas adicionais ao nosso processo de desenvolvimento.

 

Configure um canal de criação de integração contínua com um serviço como o Atlassian’s Bamboo, Jenkins ou Travis CI. Em seu pipeline de construção, você deve fazer o linting no primeiro passo. Dessa forma, se seu código não passar no teste de lint, ele não será construído, testado nem publicado.

 

2. Comente sobre seu código somente o suficiente

 

Geralmente, há dois tipos de desenvolvedores quando se trata de comentar o código: o tipo que comenta tudo e o tipo que não comenta nada. A verdade é que existem benefícios e desvantagens para ambos os lados. Por um lado, deixar muitos comentários no seu código pode torná-lo mais confuso e mais difícil de ler. Por outro lado, não ter nenhum comentário pode deixar um futuro desenvolvedor em um estado de turbulência.

 

O segredo é que você deve adicionar comentários quando eles fornecem valor. Pessoalmente, considero os seguintes truques valiosos para escrever comentários bons e significativos:

 

Comentários de topo de arquivo

 

Acho útil escrever um comentário de duas a três linhas na parte superior de um arquivo para fornecer uma breve visão geral da meta e do escopo do código. Ninguém deveria ter que gastar mais de 10 segundos olhando um arquivo para saber qual é o foco principal dele.

 

No entanto, não recomendo seguir o padrão de colocar seu nome, endereço de e-mail, data, nome de arquivo, licença e outros no comentário do topo. Todas essas informações devem estar disponíveis em outro lugar, e isso vai sobrecarregar o seu arquivo.

 

Comentários em nível de classe

 

É útil deixar um breve comentário no topo de cada classe, explicando os principais objetivos e o escopo. No entanto, se o nome da sua classe for “CarObject”, não deixe um comentário dizendo “Um objeto para representar os carros”. Deixe comentários significativos ou não deixe nada. 

 

Comentários em nível de função

 

As funções são um pouco mais complicadas para determinar o valor de adicionar comentários a elas. Por um lado, acredito que funções longas com lógica complexa devam ter comentários, apenas para economizar o tempo necessário para ler o código e entender o que ele faz. Por outro lado, não acredito que a lógica de simplificar exija um comentário. Por exemplo, se eu tiver uma variável de nível de classe chamada “x”, eu não comentaria a função chamada “get_x ()”. Isso produz uma confusão sem valor.

 

No entanto, se eu tivesse uma função de 100 linhas chamada “calculate_xyz ()”, deixaria um comentário no topo dessa função para permitir que o desenvolvedor saiba exatamente o que a função faz. Isso significa descrever as entradas, a lógica executada e as saídas. No mínimo, esse comentário evita que o desenvolvedor tenha que ler o código na função para saber o que ele faz. Pode ser a diferença entre ler 2 a 3 linhas para obter um entendimento básico e ler mais de 100 linhas para um nível de compreensão mais profundo, mas muitas vezes desnecessário (especialmente quando o desenvolvedor está preocupado apenas com as entradas / saídas da função).

 

Comentários de linha

 

Se o código for tão complexo que, depois de ler o arquivo, a classe, o comentário de função e o código em si, você ainda não o entende, ele provavelmente precisará ser refatorado. O ponto principal é este: tente o seu melhor para escrever código que você possa entender sem ter que reler. Se o seu código puder ser lido uma vez e entendido, você não precisará de comentários que confundam as partes internas de seu código, e seus colegas de trabalho perceberão como ele é abrangente e conciso.

 

3. Escrevendo código legível

 

Uma das partes mais importantes de escrever código de qualidade é escrever código legível. Depois de escrever algum código, faça uma pequena pausa por quanto tempo você precisar para limpá-lo da sua cabeça (esse intervalo pode ser de horas, dias ou semanas). Quando você retornar ao código, se não conseguir entendê-lo lendo uma vez, ele deverá ser refatorado de alguma forma.

 

Os truques a seguir ajudam a escrever um código mais legível. Pode parecer que eles não ajudam muito, mas tornar seu código o mais legível possível pode fazer muita diferença para alguém que precisa mantê-lo no futuro.

 

Use nomes bem formados

 

Use funções, classes e variáveis ​​bem nomeadas. Um nome deve lhe contar a história microscópica de como uma coisa é usada e o que ela representa. Não deveria ser uma única letra, como “x”, e não deveria ser uma frase de 70 caracteres cheia de sublinhados.

 

Variáveis ​​e funções com unidades

 

Para variáveis ​​e funções que lidam com unidades, acrescente a unidade ao final delas. Por exemplo, se eu tiver uma variável chamada “largura” que represente a largura de um elemento em pixels, ela seria melhor denominada “width_px”. Usar esse esquema de nomenclatura garante que a pessoa que usa a variável não ignore as unidades em que está. Uma coisa como usar a unidade de uma variável em seu nome pode realmente ajudar a mitigar erros críticos na produção.

 

Atenha-se aos padrões

 

Use os padrões de linguagem para variáveis, funções, strings, comentários, etc. Não é necessariamente ruim fazer as coisas de maneira diferente, mas pode afastar as pessoas, especialmente quando elas tentam lembrar o nome de uma função / variável, indo pesquisar por isso, e lutando para lembrar a nomenclatura correta.

 

Tenha um agrupamento saudável de ideias comuns em arquivos

 

Não coloque muita informação em um único arquivo. Uma boa regra é a de “uma classe por arquivo”. Se o código que estiver escrevendo não usar necessariamente as classes, tente agrupar as funções pelo objetivo principal e separar os arquivos dessa maneira.

 

A boa separação do código comum em arquivos separados pode ajudar os desenvolvedores a encontrar o código que estão procurando mais cedo, além de ajudá-los a digerir as informações que estão vendo nos arquivos com mais rapidez. Por exemplo, se tudo o que me interessa agora é X, e X, Y, Z estão juntos em um arquivo, será mais difícil digerir as informações referentes a X do que se ele estivesse em um arquivo separado.

 

4. Testando seu código

 

Para que o código seja considerado de alta qualidade, você deve ser capaz de provar que ele funciona corretamente. Você precisa fornecer uma quantidade suficiente de testes para provar a um estranho que seu código funciona da maneira que você pretendia.

 

Posso parecer apenas mais uma pessoa pregando bons testes de software, e isso é porque os testes de software são realmente importantes para escrever código de qualidade. Você precisa testar os casos esperados, os casos de borda e os casos de falha do seu código. Se você puder ter certeza de que seu código fará exatamente o que você viu em seus testes, deu um grande salto em direção a um código de alta qualidade.

 

Abaixo estão alguns truques que ajudarão você a utilizar melhor os testes de software para melhorar a qualidade do seu código:

 

Desenvolvimento orientado a testes

 

Se você aderir estritamente ao processo de escrever bons testes de qualidade primeiro, ele poderá fazer maravilhas para o seu código. Isto é acontece por várias razões.

 

Primeiro, se você está pensando em seus casos de teste antes de escrever seu código, comece a desenvolver com uma ideia clara do que seu código precisa como entrada e do que ele produz como saída. Muitas vezes, não pensamos nos nossos casos de teste antecipadamente. Como resultado, não temos a previsão sobre nosso programa que, de outra forma, teríamos. Se não pensar nos seus casos de teste com antecedência, muitas vezes precisará reescrever partes do seu código antes de concluí-lo.

 

Também força você a escrever os testes, obviamente. Às vezes, depois que escrevemos código, olhamos para ele e dizemos: “Isso é realmente simples; seria um desperdício de tempo testá-lo.” Se você estiver escrevendo testes primeiro, não terá a chance de desistir mais tarde. Se você abandonar os testes, não será possível provar de verdade que o código faz o que você pretende. Como resultado, você terá mais chances de encontrar erros no seu código.

 

Teste Automatizado

 

É importante automatizar seus testes o máximo possível, para que você não tenha uma desculpa para não executá-los. Escrever bons testes é um grande passo em frente. Mas, para ter um teste realmente autônomo, você deve integrar seus testes em uma integração contínua ou construir um pipeline, para que isso aconteça automaticamente quando você confirmar seu código.

 

Utilize diferentes níveis de teste

 

Se você já fez alguns testes, está no caminho certo. Mas não é suficiente criar um conjunto de testes de unidade. Para cobrir todas as suas bases e provar que seu programa funciona em todas as suas camadas, você precisa de testes para cada uma dessas camadas.

 

No entanto, você tem que encontrar o equilíbrio certo. Normalmente, você deseja a maioria dos testes de unidade, menos testes de integração e menos testes de ponta a ponta. Esses níveis de testes ajudam você a testar sua aplicação na íntegra e também podem tornar mais fácil para os futuros mantenedores descobrirem onde no seu código podem existir quaisquer bugs. Desenvolver código de manutenção é desenvolver código de qualidade.

 

5. Revisão do código

 

A revisão de código é o teste final de quão bem seu código pode ser entendido por outras pessoas. Aproveite sempre que puder. Ter alguém mais capaz de ler e entender seu código à sua frente é o teste definitivo para saber se seu programa será sustentável.

 

Além disso, nosso julgamento pode ficar nublado depois de trabalharmos no mesmo projeto por meses a fio. É necessário que alguém além de você revise seu código para obter uma opinião imparcial. Os truques a seguir ajudarão você a utilizar revisões de código:

 

Utilize as análises de código de equipe

 

Se você está trabalhando como parte de uma equipe, você está na posição perfeita para utilizar revisões de código. Uma maneira pela qual muitas equipes utilizam as revisões de código é que elas as conduzem depois que uma quantidade significativa de trabalho foi concluída.

 

Se você esperar até um lançamento de software para ter uma revisão de código, o que vai acontecer é o seguinte: você fará a revisão, obterá um grande feedback, deixará de comprar tudo para liberar seu software dentro do prazo e depois esquecerá o retorno.

 

É melhor planejar o tempo em sua programação para fazer ajustes depois de realizar as análises de código. Depois que sua análise de código for concluída, você realmente terá tempo em sua programação para fazer as alterações necessárias. Dessa forma, você pode garantir que o melhor software de qualidade seja lançado, liberado no prazo e que os outros possam entendê-lo melhor.

 

“O sistema de amigos”

 

Se você está trabalhando sozinho, talvez seja mais difícil, ou quase impossível, realizar análises de código. No entanto, você ainda pode realizar análises de código se encontrar um “amigo”. Considere fazer um acordo com um colega de trabalho ou apenas um dos seus amigos desenvolvedores.

 

Se você utilizar o sistema de amigos, você ainda pode obter os benefícios das revisões de código enquanto trabalha de forma independente. Apenas certifique-se de que o acordo é justo. Concordar em analisar um ao outro e tentar manter a duração do código com a mesma quantidade de tempo. Se você conseguir manter o acordo justo, será mais provável que dure mais.

 

Não discuta, aprenda

 

É importante não criticar demais alguém ao realizar uma revisão de código. Você quer que a conversa seja sobre o código, não sobre a pessoa que o escreveu. Não entre em discussões sobre opiniões variadas. No entanto, o código deve conduzir discussões.

 

Se você é a pessoa que está revisando o código, faça perguntas: Por que você fez dessa maneira? Por que você usou essa biblioteca? O que esta função faz? Esses tipos de perguntas ajudam a impulsionar as discussões. Por outro lado, se você começar a exclamar coisas do tipo “Eu teria feito dessa maneira” ou simplesmente “Esse código está errado”, provavelmente você não terá uma revisão tão produtiva.

 

Tome notas

 

Tomar notas é a parte mais importante de uma revisão de código e das reuniões mais produtivas. Não confie apenas nos revisores que estão marcando seu código. Documente as discussões que ocorrem na sessão de revisão. Mesmo que seja alcançado um consenso de que um determinado pedaço de código em questão é realmente bom, documente-o. 

 

Você pode ler essa nota mais tarde e mudar de ideia novamente. Tente capturar o máximo de informações valiosas que você puder durante a revisão. Em seguida, reflita sobre suas anotações e decida o que precisa ser priorizado.

 

Você pode escrever o melhor código da sua vida se apenas praticar. Ainda está aprendendo os primeiros passos dentro da programação? Vem aprofundar com a gente no curso Aprenda a programar em um FDS! 

 

Este curso foi projetado para colocar você na frente de discussões sobre tecnologias digitais com seus clientes e colegas. Em um final de semana cheio de atividades, você será desafiado várias vezes a entender conceitos, além de se apropriar de um vocabulário específico. Nosso objetivo não é formar programadores e programadoras profissionais em um FDS, mas sim mostrar a possibilidade e dar ferramentas de aprendizagem efetivas para a sua jornada em tech. Saiba mais acessando aqui!

 

5 dicas para aprimorar o seu código de programação
Avalie esse post
Você pode também gostar