Você encontrará muitos artigos na web sobre o que é necessário para se tornar um desenvolvedor sênior. Muitos desses artigos enfocam habilidades interpessoais. Eles geralmente aconselham manter-se atualizado com a tecnologia, aprender a se comunicar bem, orientar desenvolvedores juniores e outras coisas nesse sentido. Essas recomendações são boas e boas, mas, bem, sejamos honestos. Eles também são praticamente pabulum.
Gostaria de acrescentar um pouco de profundidade à discussão. A diferença essencial entre desenvolvedores seniores e desenvolvedores juniores é o tempo gasto nas trincheiras de desenvolvimento de software e o que eles aprenderam com isso. Com isso em mente, elaborei uma lista nada exaustiva de quatro coisas que os desenvolvedores seniores sabem, geralmente através da experiência adquirida com muito esforço.
Os desenvolvedores seniores percebem que a clareza é fundamental
A coisa mais importante que um desenvolvedor pode fazer é escrever um código legível. Isso é quase desnecessário dizer, pois é extremamente óbvio. Mas estou aqui para lhe dizer que existem vastas áreas de código que não são facilmente legíveis. Muito código é escrito sem um único pensamento ou preocupação sobre o fato de que algum pobre idiota precisará ler esse código em algum momento no futuro. E a maioria de nós não consegue perceber que, muitas vezes, esse pobre idiota seremos nós.
Um bom código não é apenas escrito com a finalidade de ser lido posteriormente, mas também é escrito com a finalidade de ser depurado. Todas as linguagens são diferentes e todos os depuradores funcionam à sua maneira, mas o código sempre pode ser escrito de uma forma que facilite a depuração.
Talvez surpreendentemente, escrever código fácil de ler e escrever código fácil de depurar andam de mãos dadas. Grande parte da depuração envolve compreender o estado de um aplicativo em execução em um determinado momento. Declarar funções, classes, etc. claramente à medida que o código é executado permite que o depurador mostre o que está fazendo. Também tem a vantagem de tornar o código legível.
A clareza no código também é alcançada escrevendo código que não precisa de comentários. Se um desenvolvedor sentir necessidade de comentar seu código, ele deve parar e perguntar por quê. Ela deve considerar fortemente que a razão pela qual ela sente essa necessidade é porque o código não está claro.
Sei que muitos discordarão de mim – conheci lojas que exigiam isso cada linha de código deve ser comentada. Mas quanto mais tempo estou no negócio do desenvolvimento, mais acredito fortemente que comentários não deveriam ser necessários. Se você sentir necessidade de comentar seu código, reescreva-o. Ou melhor ainda, sempre escreva o código na primeira vez de forma que os comentários sejam redundantes.
Os desenvolvedores seniores sabem que a complexidade é a fonte da maioria dos problemas de código
Evitar a complexidade é fundamental para um bom código. E a chave para evitar a complexidade no seu código é simples e direta: nunca escreva nada que seja complexo. Isso parece um oxímoro, mas não é.
A complexidade é fácil de evitar. Apenas pare de fazer com que qualquer coisa faça mais de uma coisa. Essa é a definição de complexidade em software: entidades que fazem múltiplas coisas. Se cada entidade em sua base de código fizer apenas uma coisa, consertar qualquer coisa envolverá consertar apenas aquela coisa que está quebrada.
Nada – nem uma classe, nem um método, nem uma função, nem uma linha de código – deveria fazer mais de uma coisa. Claro, a complexidade surgirá quando todas as partes de “fazer apenas uma coisa” interagirem umas com as outras. Mas se algo quebrar, consertar afetará apenas a coisa quebrada, e nada mais.
Não escrever coisas complexas em seu código não é o mesmo que não escrever sistemas complexos. Mas tal como um belo relógio suíço é um dispositivo complexo, ele consiste em peças simples – engrenagens e molas – que trabalham em conjunto para criar a complexidade. Pensar no seu código dessa maneira limitará a complexidade do seu código, não do seu aplicativo.
Desenvolvedores seniores resistem à tentação de ir rápido
“Lento é suave e suave é rápido” é um mantra dos Navy SEALs. Esses caras têm que tomar decisões de vida ou morte em situações de alta pressão. Parece contra-intuitivo, mas faz todo o sentido quando considerado. A ideia é que quando estamos com pressa, estamos sujeitos a cometer erros – quanto mais corremos, mais erros. Erros levam muito tempo. Ir devagar – sem pressa – reduzirá ou eliminará erros, e não cometer erros torna o processo geral mais rápido.
Os desenvolvedores seniores sabem que esse princípio também funciona para código. Código apressado é um código ruim. Os desenvolvedores seniores sabem que reservar um tempo para fazer as coisas certas da primeira vez significa menos erros, menos linhas de código inescrutável e melhores resultados no futuro, quando o código for mantido.
Eles sabem que nada de bom resulta da pressa. Um ótimo software vem de ser deliberado, cuidadoso e atencioso ao escrever o código.
Desenvolvedores seniores sofrerão no curto prazo para obter ganhos no longo prazo
Todos nós fizemos isso. Lançamos alguns novos recursos no fim de semana, hackeando tudo e fazendo com que funcionasse com total desdém pela qualidade do que estamos fazendo. Há muitas razões para isso, mas todas são motivadas pelos negócios, certo? Um cliente não assinará um acordo sem ele, ou partirá para um concorrente se não o tiver na segunda-feira de manhã. Ou uma demonstração precisa ser concluída para uma apresentação em uma conferência, e essa demonstração se transforma no recurso real.
E nós sempre me arrependo de ter feito isso. Sempre. O código em si é difícil de corrigir quando bugs inevitáveis são encontrados. O sabor agregado do recurso quebra três outros módulos do aplicativo, causando outra crise nos negócios. É um carrossel que nunca para. Mas fazemos isso de qualquer maneira.
Um bom desenvolvedor sênior sabe resistir o máximo possível e limitar os danos quando isso acontecer.
Claro, habilidades de comunicação e orientação de desenvolvedores juniores são coisas importantes para um desenvolvedor sênior. fazermas o que eles saber através da experiência é o que realmente os diferencia. Os desenvolvedores seniores sabem manter o código claro e simples, ir devagar e ter uma visão de longo prazo.
