Como melhorar como Programador – Junior, Pleno e Sênior as diferenças

Tempo de Leitura: 10 Minutos

Ser um desenvolvedor júnior, de nível médio ou sênior não tem a ver apenas com os anos de experiência em programação que você tem. Um desenvolvedor júnior pode até ser mais velho que um desenvolvedor sênior, ou, um sênior em um determinado ambiente pode ser júnior em outras situações, o que faz a diferença é o tempo de aprendizado e a forma de agir em determinadas situações, ou seja, tudo se resume à habilidade. Isso não significa que um desenvolvedor sênior precisa ser um especialista em tudo, mas é seguro dizer que os desenvolvedores sênior são muito mais qualificados do que os desenvolvedores juniores e intermediários. Porém, mais do que apenas habilidades de codificação, vamos falar neste artigo as peculiaridades que identificam o seu grau de AMADURECIMENTO quando se trata de desenvolvimento de software.

Conhecimento

Espera-se que um desenvolvedor sênior além do conhecimento profundo das estruturas da linguagem e do ambiente em que ele está desempenhando sua função também tenha sólidos conhecimentos em padrões de design, arquitetura do ambiente, automatização de testes, implicações de desempenho, implicaçõem em segurança, impacto de uma mudança estrutural ou pontual, ou seja, a lacuna de conhecimento é pequena, mais vai fazer uma grande diferença em termos gerais. É importante saber como as coisas são feitas corretamente no desenvolvimento de software. Porém, o conhecimento não é a maior diferença entre os desenvolvedores – é apenas um dos fatores.

Codificação

Apesar do que a maioria das pessoas pensa, codificação não é a comunicação com o computador, é interpretar a forma como humanos e computadores vão interagir, ou seja é comunicar-se com humanos para instruir computadores a executarem uma determinada tarefa repetitiva. Eventualmente, o código é compilado e traduzido para zeros e uns, que é a linguagem do computador.

O código produzido, por um programador de nível mais elevado, deve fazer sentido não para o computador que o está executando e sim para outros desenvolvedores que trabalharão com ele no futuro. Os computadores simplesmente, quando não entendem uma determinada instrução, não a executarão, e vão produzir um erro, e desse modo seu código simplesmente não é exectado. Já humanos quando não conseguem entender o código, para poder dar uma manutenção ou realizar uma nova implementação, precisam perder horas de seu valioso tempo tentando interpretar o que aquele bloco de código faz.

Uma nova equipe, que nunca viu a base de código antes deve ser capaz de abri-lo e começar a trabalhar em novos recursos ou correções de bugs praticamente no mesmo instante. É aqui que está a grande diferença entre os desenvolvedores juniores e seniores. Neste caso, os desenvolvedores júnior e sênior produzem códigos que são mais facilmente interpretados, os junior pela baixa complexidade e facilidade de compreensão, e o sênior pela maturidade do código, uso consiso de variáveis e valores, e pela qualidade técnica.Isso tem a ver principalmente com a experiência, uma vez que os desenvolvedores de nível médio ainda não estão familiarizados com as principais técnicas e ferramentas, mais já possuem experiência suficiente para desenvolverem soluções com mais alta complexidade, pois provavelmente já passaram por todo o ciclo de desenvolvimento pelo menos uma vez. Eles cometeram muitos dos erros mais simples e aprenderam com eles.

Como farejar o desenvolvedor júnior? Os desenvolvedores juniores são inexperientes no uso das ferramentas, alguns acabaram de se formar e estão começando seu primeiro emprego de tempo integral. A mentalidade geralmente é apenas fazer o código funcionar, como eles ainda não possuem a bagagem não se preocupam com o impacto que uma alteração pode causar em termos de desempenho, ou mesmo de segurança ou escalabilidade. Software funcional e bom software são considerados a mesma coisa, ou seja, se funciona tá bom.

Programar corretamente é difícil, escrevem códigos sofisticados estruturas curiosas e abstrações excessivamente complexas é fácil. Os desenvolvedores juniores se concentram no lado do computador do código em detrimento do lado humano. Um código complexo pode ser tão facilmente interpretado por um computador como um código simples, porém, um código complexo vai tomar tempo de um humano para ser analisado, testado e entrar em uma base de produção.

E o desenvolvedor sênior? Ao examinar o código de um desenvolvedor sênior, você pode pensar: isso é tudo? Um desenvolvedor sênior escreve um código simples, direto e talvez até burro. Esta é uma das maiores qualidades que um desenvolvedor pode ter quando se trata de programação. O código escrito por um desenvolvedor sênior será feito com a manutenção e escalabilidade em mente, pois ele está pensando nas pessoas que precisam trabalhar com o código junto com ele, em como ele deve ser portado e escalado em casos de necessidades, quanto ele custa em termos de processamento, e onde ele pode ser melhorado, se ele pode sofrer com falhas humanas e onde estão os pontos críticos.

Mais do que apenas codificação

Além das habilidades de codificação, existem alguns outros fatores que podem determinar o nível do desenvolvedor, desenvolvedores juniores, em geral, realizam tarefas simples ou com baixo impacto, geralmente porque não tem um grande conhecimento do projeto de arquitetura, isso não significa que eles não sabem utilizar uma ferramente técnica, e sim, o impacto que aquela pequena modificação, que um simples esquecimento em liberar um único byte da memória pode impactar no desempenho depois de milhoes de ciclos. Os desenvolvedores de nível médio muitas vezes já estão preparados para este tipo de soluções, mais muitas veses, eles focam apenas em realizar tarefas, já dominam total e plenamente a linguagem e ferramentas usadas em todo o ciclo do software, porém, ainda esquecem do impacto de algumas ações ou na preocupação com o todo, não só com seu trabalho.

Já um desenvolvedor senior pode realizar o desenvolvimento da aplicação completamente, isso não significa que não tenha perguntas e dúvidas ao longo do caminho, a diferença é saber como fazer as perguntas certas e como essas perguntas são tratadas, ou seja, ele vai em caso de dúvidas, saber se localizar em uma documentação ou manual técnico, já desenvolvedores em outros níveis vão encontrar maior dificuldade, por exemplo em obter uma ajuda em um fórum ou na própria documentação.

Um desenvolvedor mais maduro, nunca está perdido, ele sabe como e onde ele deve acompanhar a questão, e quais as possíveis causas para uma certa ação. Isso não significa que um desenvolvedor sênior não possa pedir ajuda a outros desenvolvedores, em casos de dúvidas a melhor maneira é pedir ajuda a outros desenvolvedores com experiência nessa área, até mesmo a um desenvolvedor júnior ou intermediário que tenha conhecimento daquele ponto em específico. Não é incomum, principalmente quendo se usa soluções híbridas em níveis de linguagem, que um determinado desenvolvedor mesmo que hieráruicamente em um nível menor, tenha total domínio de uma parte do software, em ambientes web isso é muito comum, um grupo de desenvolvedores terem um membro especialista em uma linguagem e outro em outra, e um lead técnico sênior para coordenar toda a equipe.

O desenvolvedor de nível médio também deve ser capaz de fazer as perguntas certas, contanto que não receba tarefas altamente complexas para o seu nível de conhecimento ou maturidade com aquela parte do problema ou com o projeto sendo visto de maneira global.

Como chegar ao próximo nível?

Todos nós queremos nos aprimorar e melhorar como desenvolvedores, então, quais são as etapas que devemos seguir para chegar ao próximo nível? Como os desenvolvedores junior são inexperientes, é importante passar por todo o ciclo de desenvolvimento pelo menos algumas vezes, ou seja, conecer bem a linguagem que estamos utilizando, seus recursos e como implementar utilizando sua sintaxe as principais ferramentas, conexões com bancos de dados, interligação com outras linguagens e ferramentas, configurações do ambiente e recursos disponíveis. Dessa forma, você acabara cindo em muitas armadilhas e aprenderá como evitá-las da próxima vez.

Quando se trata de codificação, você deve aprender a escrever código o mais simples possível, não pense em como o computador vai executa-lo, pense na próxima pessoa que trabalhará naquele código depois de você, e como você se sente ao ler um código escrito por outras pessoas, evite repetir exatamente o que não te deixa confortável. Você também deve aprender como depurar, pois isso lhe dará uma melhor compreensão do que está acontecendo no processo como um todo. Além disso, tente se familiarizar com as práticas recomendadas e aprender sobre arquitetura, desempenho, segurança, escalabilidade, implementação de estruturas e design patterns. Elimine a lacuna de conhecimento necessária para chegar ao nível médio.

Passar do nível médio para um mais elevado pode ser bastante difícil, a grande maioria dos desenvolvedores para nesse nível durante toda a carreira. Desenvolvedores experientes sabem quais cantos podem ser cortados e aparados e quais cantos nunca devem ser mexidos essas são lições aprendidas com dificuldade por cometer erros no passado. Você deve estar preparado para assumir tarefas que outros não sabem como consertar, não só fazer o trabalho de desenvolvimento, mais também, melhorias de desempenho, melhorias de qualidade, escalabilidade e longevidade do projeto, implementação de novos recursos e integrações com os mais diversos ambientes.

Como desenvolvedor sênior ou seu trabalho também é ajudar os desenvolvedores menos experientes, e não pode ter o receio de saber indicar o caminho das pedras para todos os níveis de desenvolvedor que sua equipe tem. Você é o substituto de outros desenvolvedores quando eles não sabem fazer algo, portanto deve conhecer todos os aspectos da ferramenta que você tem em mãos, saber todos os fluxos de dados e de processament possíveis dentro da ferramenta ou do grupo de ferramentas. Ter conhecimentos sólidos sobre a arquitetura que você está utilizando, para poder prever gargalos e possíveis falhas técnicas de disponibilidade antes delas acontecerem, além de saber tudo o que está sendo feito e como está sendo feito pelos outros membros da equipe, um desenvolvedor sênior, tem a obrigação de conhecer todas as ferramentas e linguagens utilizadas em todas as partes do processo que compoẽ o software e suas bibliotecas, conseguir, intervir mesmo que em bases de código importadas e saber como buscar recursos e ferramentas para melhorar seu trabalho.

Dominar toda a pilha de tecnologia, não somente habilidades de codificação, conhecer todas as ferramentas e aplicativos que estão sendo usados ​​na empresa para a qual você trabalha, saber identificar os melhores recursos e linguagens para determinados projetos, um desenvolvedor de nível médio geralmente tem um problema que é justamente conhecer muito uma determinada linguagem e achar que ela é a ferramenta certa para tudo – Se você só sabe usar o martelo, todo seu trabalho vai se parecer com um prego – essa frase é uma grande verdade quando lidamos com alguns desenvolvedores de nível intermediário, seu profundo conhecimento em alguns projetos fazem com que eles tenham uma visão ainda distorcida do todo, e tenham a tendência a visualizar todo o projeto utilizando  as ferramentas que eles dominam, não dando abertura para novos projetos.

Conclusão

A diferença entre um desenvolvedor júnior, de nível médio e sênior não é apenas sobre os anos de experiência, mais sobre o quão qualificados são para atuar nas diversas frentes de trabalho do desenvolvimento de software, claro, todos nós desde os mais novos até profissionais com anos de experiência temos ferramentas e preferências, mais profissionais mais experiêntes tem a tendência de saberem melhor quando recuar e quando avançar com uma proposta.

Desenvolvedores seniores escrevem códigos mais fáceis e vêm com uma mentalidade diferente dos desenvolvedores juniores, um grande diferencial para um líder técnico é saber tirar o melhor proveito de cada membro de sua equipe, otimizando o resultado global, mesmo que em detrimento de um ou outro ponto irrelevânte, um bom profissional sabe quando ele deve delegar uma tarefa, e quando é o momento certo de assumir o controle. Saber ajudar e pedir ajuda quando necessário, é um grande diferencial, a maturidade profissional, e os anos de experiência vão ensina-lo que ajudar os demais vai melhorar o desempenho da equipe como um todo, um outro grande problema em profissionais medianos é o medo de ficar para traz e não conseguir alcançar níveis mais elevados na hierarquia, já ví centenas de ótimos profissionais que acabam se estagnando em uma posição mediana, pelo medo de auxiliar sua equipe, um profissional que atingiu um nível de maturidade suficiente para saber ensinar vai ser um profissional candidato a súbir de nível, pois ele perde o medo de ser passado para traz, pois tem a plena certeza de seu conhecimento.

Para crescer como desenvolvedor, você deve se concentrar em escrever um código simples e passar por vários ciclos diferentes de desenvolvimento, se concentrar em aprender mais do que apenas consertar tarefas de rotina e entregar somente o que foi proposto, deve estar disposto a assumir as tarefas mais difíceis e ser um mestre em sua pilha de tecnologia. Outra responsabilidade é ser o substituto para desenvolvedores menos experientes e para qualquer profissional abaixo do seu nível hierárquico, mesmo que não seja um expert em uma determinada faceta ou linguagem, você deve ser capaz de utiliza-la. Vou deixar uma citação de Martin Fowler: “Qualquer idiota pode escrever um código que um computador possa entender. Bons programadores escrevem códigos que humanos podem entender. ”