Tech

Erros que todo desenvolvedor comete ao (aprender a) programar

Laura Loenert

• 7 min read
Erros que todo desenvolvedor comete ao (aprender a) programar

Existem muitos tipos de erros que todo desenvolvedor pode cometer ao programar. Em geral, a maior parte desses erros normalmente surgem de (maus) hábitos iniciados enquanto se aprende algo novo. Por exemplo: alguma vez você já tentou adicionar cada padrão de design a cada trecho de código que escreve? Quem nunca, não é mesmo? Porém, ao fazer isso, seu código-fonte se tornará uma bagunça talvez até para você mesmo. Neste caso, implementar um código limpo usando apenas padrões de design relevantes pode ser a melhor solução (especialmente para quem for lidar com seu código depois).

Neste post, listamos alguns errinhos comuns aos quais você pode se atentar no dia a dia, e como evitar ao máximo cair em ciladas desse tipo. Mas, antes de começarmos, uma perguntinha básica:

Qual o seu planejamento antes de pensar em criar código?

Planejar antes de começar a escrever código é sempre uma boa ideia. Seu planejamento pode até mudar, mas ao menos terá servido para criar alguma estrutura que leve a mais clareza na produção do código. Agora, é preciso sempre atentar para o equilíbrio entre plano x ação: planejar demais pode fazer com que você perca muito do seu precioso tempo. E, como sabemos, “tempo é dinheiro”, especialmente para desenvolvedores!


Os 3 tipos de erros mais comuns ao criar código


Existem 3 tipos de erros na programação que costumam ser os mais comuns: os de lógica, sintaxe e de tempo de execução (runtime). Esses são erros em que o compilador encontra algo estranho no programa que você está desenvolvendo, e o resultado é não conseguir executá-lo. Vamos aos detalhes de cada um deles:


Como minimizar erros de lógica no código?


Erros de lógica ocorrem quando há uma falha na lógica de programação ou estrutura do problema. Normalmnte, erros de lógica não causam a falha de um programa, mas podem fazer com que um software produza resultados inesperados. Portanto, antes de desenvolver qualquer programa, procure anotar ideias, fórmulas, funções, cálculos ou mesmo o tipo de algoritmo que o programa irá executar.

Lembre-se que um programa com erro de lógica pode dar a resposta correta algumas vezes e a resposta errada outras tantas vezes. Uma dica é verificar os requisitos detalhadamente antes de iniciar a programação de qualquer sistema ou software. Erros de lógica são em geral os mais difíceis de encontrar e corrigir.

E se você pensa que esse é um pequeno erro que pode ser corrigido depois, vale a pena ler a história completa por trás do Mars Climate Orbiter da NASA. Em 1999, a NASA perdeu o satélite Mars Climate Orbiter, de US$ 125 milhões, por conta de uma falha na conversão de unidades de medida inglesas para o sistema métrico. Parece coisa pequena, né? Fato é que o programa funcionou corretamente até um certo ponto, e os engenheiros não perceberam que tinham cometido um erro, até que fosse tarde demais para corrigi-lo. Em cálculos atuais, a perda foi de mais de meio bilhão de reais com o erro fatal - e tudo por conta de um “errinho” de lógica.

Erros de sintaxe

O erro mais comum na programação são os erros de sintaxe, que são o equivalente em programação aos erros gramaticais em português que todos cometemos. A boa notícia é que eles também são alguns dos mais fáceis de encontrar e corrigir, pois o compilador geralmente identificará a localização de qualquer um desses erros.

Alguns dos erros de sintaxe mais comuns são:

  • Omitir um parêntese ()
  • Esquecer um ponto e vírgula ao final de uma linha ;
  • Esquecer um colchete ao final de uma função []
  • Maiúsculas FORA do lugar
  • Instruções incorretas


Erros de tempo de execução

Esses bugs ocorrem quando o código “não funciona bem” em outra máquina, mesmo que tenha funcionado corretamente na máquina do próprio desenvolvedor. Esses erros são particularmente frustrantes porque impactam diretamente o usuário final e fazem com que a aplicação pareça “quebrada” ou mesmo não confiável.

Testes de usuários, bom suporte técnico e um sistema de identificação de bugs são uma boa maneira de identificar e corrigir esses erros. Como esse tipo de erro costuma se repetir, as squads de desenvolvimento devem se concentrar em criar um sistema de relatórios de bug eficaz e buscar, sobretudo, aprender com eles. Afinal, quanto mais aprendemos com nossos erros, menos eles tendem a acontecer no futuro.

Outros tipos de erros que você deve evitar HOJE


Erros de compilação

Compilação é o processo de conversão de uma linguagem de codificação de alto nível em uma linguagem de baixo nível que pode ser melhor compreendida pelo computador. Erros de compilação ocorrem quando o compilador não consegue transformar corretamente o código de alto nível em um de nível inferior. Isso impede que o software seja iniciado ou testado.

Erros de interface

Esses bugs geralmente acontecem quando as entradas (inputs) que o software recebe não estão em conformidade com os padrões aceitos. Quando tratados incorretamente, esses erros podem parecer erros do lado do desenvolvedor, mesmo quando estão do lado de quem fez a chamada, e vice-versa.

Erros de recursos

Às vezes, um programa pode forçar o computador em execução a tentar alocar mais recursos (energia do processador, memória de acesso aleatório, espaço em disco, CPU etc). Isso faz com que o programa apresente bugs ou até mesmo que o sistema falhe como um todo.

Erros aritméticos

Esses erros se assemelham aos de lógica, mas com matemática aplicada. Por exemplo, uma equação de divisão pode exigir que o computador divida por zero. Como isso é matematicamente impossível, resulta em um erro que impede que o software funcione corretamente.

Nomenclatura ruim de variáveis

Esse é de longe o erro mais comum que programadores iniciantes cometem. Procure nomear suas variáveis e funções como se um leigo pudesse ler e compreender o que cada uma significa. Afinal, depois de alguns meses, você vai lembrar o que significa a variável nomeada como “dsld”, ou o que aquela função “nstnc_crt” faz? Possivelmente não, pois são termos que criou pensando no seu próprio entendimento, e não da comunidade de uma maneira geral.

Não usar comentários

Comentar é uma maneira incrível de lembrar do que um trecho de código faz. Muitos iniciantes não utilizam comentários, o que torna o código confuso e difícil de ler. Vale lembrar, no entanto, que também deve haver um equilíbrio sobre quantos comentários você deve usar em seu código. Por exemplo, se adicionar muitos comentários, terá que alterá-los toda vez que alterar o código que está escrevendo. Assim, é recomendável comentar apenas quando um trecho do código não for completamente autoexplicativo.

Não manter a formatação do código consistente

Não importa se você colocar os colchetes na mesma linha que o “if” ou se você nomeia variáveis com maiúsculas ou sublinhadas. Apenas certifique-se de manter a formatação do seu código consistente. Pois ao não fazer isso, o resultado será um código com cara de amador e (pior ainda!) difícil de manter.

Não fazer backup do projeto

Eis um erro que pode custar anos da sua vida. Fazer backup de código é extremamente importante, mesmo se você não estiver trabalhando em equipe. O GitHub criou uma ótima aplicação chamada GitHub Desktop que serve como ponte para sincronizar e salvar o trabalho sem que o desenvolvedor tenha sequer que tocar na linha de comando. E o melhor de tudo: é grátis.

Usar uma linguagem excessivamente complicada

Não se sinta pressionado a programar em uma linguagem apenas porque é o que muitos outros fazem. Também procure fugir de algo muito personalizado. Existem inúmeras linguagens fáceis de entender que são mais amigáveis para iniciantes. E, uma vez que você conhece uma linguagem, a tendência é que seja mais fácil aprender qualquer outra linguagem daí em diante.

Não usar o debugger

Quando se deparar com um erro de código que não sabe como resolver, não cometa o erro de apenas mergulhar no código e ler. Use o debugger para fazer isso, disponível na maior parte dos IDEs. Com o debugger, a solução de problemas é muito mais fácil. Você pode assistir seu código sendo executado linha por linha, e dessa forma acompanhar exatamente o que possa estar dando errado nele.

Criar funções que são muito grandes

Não crie funções que recebam muitas entradas ou funções que realizem apenas uma tarefa muito específica. Divida sua função em várias outras funções, que são mais fáceis de ler e manter.

Muito cuidado com tutoriais

Tutoriais podem ser extremamente úteis quando se está aprendendo a programar. No entanto, enquanto desenvolvedores, nossa principal missão deve ser construir e entregar Produtos. Os novatos na área frequentemente ficam desorientados e não sabem por onde ou como começar. Em vez disso, eles vídeo após vídeo em canais no YouTube, em busca de novos tutoriais. Esse não é o caminho certo para aprender coisas novas.

Em vez disso, a maneira mais eficaz de assistir a tutoriais é, em primeiro lugar, tomar uma decisão sobre o quê você deseja construir. Em seguida, pesquise por um tutorial adequado. Os vídeos mais populares costumam ser os melhores. Com toda a atenção que puder, procure assistir do inicío ao fim. Depois, faça uma tentativa de reconstituir você mesmo tudo o que aprendeu. Travou? Repita o processo e anote-o. Por fim, reconstrua o projeto no seu próprio estilo depois de concluído.

Não copiar e colar código sem entender bem antes

Muitos desenvolvedores procuram respostas no Google e depois copiam e colam o código de outra pessoa em seu próprio código. Essa é uma prática comum, e que pode realmente ajudar a acelerar o trabalho e a ensinar muito sobre programação – mas se for usada corretamente.

Ler, entender e escrever o código que você mesmo escreveu e em seu próprio estilo o ajudará a aprender as coisas de maneira mais rápida e eficaz. Criar algo você mesmo nos ajuda a fixar melhor o conhecimento do que simplesmente copiar/colar sem analisar o que está realmente está acontecendo. Conhecer a lógica e a função do seu próprio código também o ajudará a se destacar da multidão.

Não siga a estratégia de outra pessoa

Esse é um erro típico quando se aprende a programar. Você pode ficar tentado(a) a usar as mesmas ferramentas (erradas) de outra pessoa. Mas aqui é sempre preciso lembrar que não necessariamente aquilo que funciona para um funcionará também para você - especialmente em programação.

Não tenha medo de reviews de código


Um review de código é um método que fornece feedback sobre o código de alguém, principalmente no caso de pull requests. Você deve estar aberto a recomendações e críticas de desenvolvedores mais experientes em sua área e a receber conselhos com humildade – mas não tenha medo também de fazer perguntas e se aprofundar no assunto.

Os reviews de código podem ajudar a identificar bugs, verificar se o código está legível e é de fácil manutenção, além de disseminar o conhecimento da base para toda a equipe.


Os #10 Mandamentos da Programação:

#1. Definir metas
#2. Praticar a paciência
#3. Prestar atenção ao básico
#4. Praticar a programação à mão
#5. Aprender fazendo, não memorizando
#6. Tornar-se seu próprio solucionador de problemas, porém:
#7. Não há problema em pedir ajuda
#8. Cometa erros e depois aprenda com eles
#9. Não desista
#10. A aula de programação que você escolhe é importante

…E por último, mas não menos importante:

Tanto os bons programadores quanto os maus programadores cometem erros estúpidos. A diferença é que bons programadores: