Meu Código NÃO Tá Bom. Desanimei. E Agora?

Você criou um projeto. Fez funcionar. Mas quando olha para o código, bate uma sensação ruim: não sei se isso tá seguindo boas práticas. Não sei se tá organizado do jeito certo. Não sei se tô aplicando SOLID. Não sei se outro programador abriria isso e daria risada.

Isso desanima. E esse desânimo faz muita gente parar de estudar, ou pior, parar de criar.

Quero te falar uma coisa: isso é um problema de expectativa, não de código.

O que acontece no aprendizado

Quando você começa a estudar qualquer coisa, você parte do nível básico. Com o tempo chega no intermediário. Quando chega no intermediário, você olha para o que aprendeu no básico e percebe que estava incompleto. Não necessariamente errado, mas incompleto. Você vê como poderia ter feito melhor.

Quando chega no avançado, o mesmo acontece com o intermediário. Você melhora, e por consequência o que você fez antes parece fraco.

Isso é o processo de aprendizado funcionando corretamente. É o que deveria acontecer.

O problema é que quando você vai criar os próprios projetos, de alguma forma você esquece tudo isso. Você espera que a primeira versão do seu código seja a perfeição da humanidade. Que nunca mais vai precisar tocar naquilo porque já tá perfeito, com a melhor performance, a melhor organização, o melhor padrão possível.

Não é assim que funciona. E esperar que seja assim é o que gera o desânimo.

Versão 1.0 existe por uma razão

Todo software que você usa passou por uma versão 1.0. Sabe o que era essa versão? Provavelmente feia, com gambiarras, sem os padrões que o projeto usa hoje.

Você fez a versão 1.0 do seu projeto. Ela não precisa ser perfeita. Ela precisa funcionar.

Depois que funciona, você vai identificar um bug, vai corrigir. Vai ver que adicionar um novo recurso naquele trecho vai ser sofrido, então vai reorganizar. Vai ver que aquela função tá fazendo coisas demais, vai dividir. Cada melhoria dessas é uma nova versão: 1.1, 1.2, 1.3.

Em algum momento você vai pegar tudo que aprendeu nessas iterações, jogar fora o projeto antigo e recriar do zero. Esse do zero vai ser melhor em tudo. Esse é o 2.0.

E então o ciclo começa de novo.

Faz funcionar. Depois melhora.

Código não é tinta em papel. Você não imprime e entrega e não consegue mais mexer. Você pode apagar, reescrever, reorganizar, refatorar.

O processo certo é esse: primeiro faz o negócio funcionar. Não se preocupa se tá bonito, se tá seguindo todos os princípios, se tá da forma mais elegante possível. Faz funcionar.

Depois você refatora. Refatorar é pegar um código que funciona e melhorar ele sem quebrar o que já funciona. Você melhora a organização, extrai funções, remove repetição, aplica um padrão onde faz sentido.

Depois você refatora de novo. E de novo.

Isso não é fraqueza ou preguiça, é como software funciona na prática. Qualquer projeto real passa por isso.

O código de hoje é o melhor que você consegue fazer hoje

Aceita isso: o código que você tá olhando agora, aquele que parece não tá bom o suficiente, é o melhor que você consegue fazer nesse momento com o conhecimento que você tem.

Amanhã você vai saber mais. Daqui a seis meses vai saber ainda mais. Vai olhar para esse mesmo código e vai ver exatamente o que melhorar.

Isso é progresso. É o processo funcionando.

A cada novo projeto, a sua versão 1.0 vai ser melhor do que a versão 1.0 anterior. Não porque você magicamente ficou bom, mas porque você acumulou experiência real criando e melhorando coisas.

Quando você tiver muita experiência, a sua versão 1.0 já vai ser excelente. E mesmo assim você vai ver como melhorar ela. Porque é assim que funciona para todo mundo, independente do nível.

O que fazer com esse desânimo

Não luta contra ele esperando que o primeiro código seja perfeito. Isso não vai acontecer.

Faz o projeto funcionar, sente orgulho de ter feito algo funcionar, e depois melhora. Quando você melhorar, vai olhar para a versão anterior e sentir um leve constrangimento. Isso é bom sinal. Significa que você evoluiu.

O programador que nunca sente vergonha do código antigo é o programador que parou de aprender.

Continua criando. Continua melhorando. Sem pressa de ter tudo perfeito desde o começo.