As diferenças entre um #desenvolvedor júnior, pleno e sênior

Tempo de leitura: 8 minutos

Ser um desenvolvedor júnior, pleno 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. Tudo se resume a habilidades.

Isso não significa que um desenvolvedor sênior precisa ser especialista em tudo, mas é seguro dizer que os desenvolvedores seniors são muito mais qualificados do que os desenvolvedores juniors e plenos.

Mas são mais do que apenas habilidades de codificação que diferenciam o desenvolvedor sênior do desenvolvedor pleno e júnior. Então, quais são essas habilidades?

Conhecimento

Obviamente, o desenvolvedor sênior tem muito mais conhecimento do que o desenvolvedor júnior e o pleno. Conhecer padrões de design, arquitetura, testes de automação, desempenho, segurança, etc é uma boa maneira de um desenvolvedor júnior fechar a lacuna de conhecimento com os desenvolvedores pleno e sênior. É importante saber como as coisas no desenvolvimento de software devem ser feitas. Mas saber tudo isso não faz de você um desenvolvedor sênior. O conhecimento não é a maior diferença entre os desenvolvedores, é apenas um dos fatores.

Codificação

Apesar do que a maioria das pessoas pensam, codificar não é só um ato de se comunicar diretamente com um computador. A codificação é sobre tudo a comunicação com humanos passando instruções para computadores. Eventualmente, o código é compilado e traduzido para 0 e 1. O código tem que fazer sentido para outros desenvolvedores que trabalham ou trabalharam com ele no futuro. Uma nova equipe que nunca viu o código antes deve ser capaz de abrir o código e começar a trabalhar em novos recursos ou correções de bugs de forma simples e clara. É aí que entra a grande diferença entre desenvolvedores juniors e seniores. Deixarei de fora o desenvolvedor pleno nessa comparação, porque o desenvolvedor pleno é uma área cinzenta quando se tratando de habilidades de codificação. Obviamente, é em algum lugar entre o júnior e sênior. Provavelmente se inclina mais para o lado sênior.
Isso tem a ver principalmente com a experiência, já que os desenvolvedores plenos provavelmente passaram pelo ciclo de desenvolvimento inteiro pelo menos uma vez. Eles fizeram muitos dos erros mais simples e aprenderam com eles.

E como saber quem é júnior ?

Os desenvolvedores juniors são inexperientes. Alguns acabaram de se formar e estão começando seu primeiro emprego em tempo integral. A mentalidade de um desenvolvedor júnior, muitas vezes, é apenas fazer o código funcionar.

Programar código simples é difícil. E é algo que os desenvolvedores juniors não fazem. Os desenvolvedores juniors escrevem códigos extravagantes. Você pode reconhecer o desenvolvedor júnior por meio de frases curiosas e abstrações excessivamente complexas. Essa é a maneira como o desenvolvedor júnior mostra e deixa os outros desenvolvedores saberem o quão bons eles podem codificar. E isso está errado. Desenvolvedores juniors concentram-se no lado do computador do código em detrimento do lado humano.

E o desenvolvedor sênior ?

Ao olhar para o código de um desenvolvedor sênior, você pode pensar: isso é tudo o que existe? Onde está o resto do código? Um desenvolvedor sênior escreve um código simples, direto e talvez até idiota. Esta é uma das maiores qualidades que um desenvolvedor pode ter, quando se trata de programação.
Um desenvolvedor sênior segue o princípio KISS: ( Keep it simple, stupid) Mantenha-o estupidamente simples.

Um desenvolvedor sênior pensa sobre o código de maneira diferente do desenvolvedor júnior. Código escrito por um desenvolvedor sênior será feito com sustentabilidade e escalabilidade em mente. Esta é uma mentalidade totalmente diferente do que o desenvolvedor júnior tem – o sênior está pensando sobre as pessoas que têm que trabalhar com o código, enquanto o júnior está apenas pensando em fazê-lo funcionar para o computador.

Mais do que apenas habilidades de codificação

Keep it simple, stupid (Mantenha-o estupidamente simples)

Além das habilidades de codificação, existem outros fatores que podem determinar qual é o tipo de desenvolvedor. Os desenvolvedores juniors, em geral, executam as tarefas mais simples com baixo impacto. Eles não fazem nenhum design de arquitetura. Os desenvolvedores de nível pleno não estão projetando soluções, apenas executam tarefas. A diferença com o desenvolvedor júnior é que eles executam essas tarefas com menos supervisão, desde que sejam atribuídas a tarefas relativamente rotineiras.
Desenvolvedores seniors podem desenvolver um aplicativo completamente por conta própria. Isso não significa que o desenvolvedor sênior não tenha dúvidas ao longo do caminho. Todo desenvolvedor tem muitas perguntas todos os dias e isso não muda nada. Isso não é diferente para desenvolvedores seniors.
A diferença é que os desenvolvedores seniors sabem como fazer as perguntas certas e como essas questões são tratadas. Desenvolvedores de nível médio podem fazer as perguntas certas quando se trata de tarefas relativamente rotineiras, mas precisam de ajuda em tarefas mais complexas. O desenvolvedor sênior nunca se perde sabendo acompanhar a questão com a ação correta. Isso não significa que um desenvolvedor sênior não possa pedir ajuda de outros desenvolvedores.
Às vezes, a melhor maneira é simplesmente pedir ajuda a outros desenvolvedores com experiência maior na area que está sendo tratada. O desenvolvedor de nível pleno também deve poder fazer as perguntas certas, contanto que não seja atribuído as tarefas altamente complicadas que exijam um nível de conhecimento aprofundado. Você não deve esperar que um desenvolvedor júnior faça as perguntas certas imediatamente. Como os desenvolvedores juniors são inexperientes, eles precisam de orientação de um desenvolvedor mais experiente. O desenvolvedor júnior precisa receber os recursos necessários ou um grande impulso na direção certa.

Chegando ao próximo nível

Todos nós queremos melhorar como desenvolvedor. Mas quais são as etapas que você pode seguir para chegar ao próximo nível?

Júnior para Pleno

Como os desenvolvedores juniors são inexperientes, é importante passar por todo o ciclo de desenvolvimento pelo menos algumas vezes. Desta forma você vai cair em muitas armadilhas e aprender como evitá-las na próxima vez. Quando se trata de codificação, você deve aprender a escrever código simples. Pense na próxima pessoa que vai trabalhar nesse pedaço de código. Você também deve aprender a depurar, pois isso permitirá que você entenda melhor o que está acontecendo no processo. Além disso, você deve se familiarizar com as melhores práticas e aprender sobre arquitetura, desempenho, segurança, etc. Feche a lacuna de conhecimento necessária para chegar ao nível pleno.

Pleno para Senior

Começar de nível pleno para sênior pode ser bastante difícil. Alguns desenvolvedores permanecerão no nível pleno durante toda a duração de sua carreira. Desenvolvedores seniors sabem que cantos podem ser cortados e quais cantos nunca devem ser cortados. Essas são lições difíceis, cometendo erros no passado. Se você quiser chegar ao nível sênior, você tem que estar preparado para assumir as tarefas que ninguém sabe como consertar. Você deve saber mais do que apenas como fazer o trabalho. Como desenvolvedor sênior, seu trabalho também é ajudar os desenvolvedores menos experientes. Você é o substituto de outros desenvolvedores quando eles não sabem como fazer algo. E talvez não surpreenda você que desenvolvedores experientes dominem sua pilha de tecnologia. Há mais do que apenas habilidades de codificação. Conheça todas as ferramentas e aplicativos que estão sendo usados na empresa em que você trabalha.

Conclusão

A diferença entre um desenvolvedor júnior, pleno e sênior não é de apenas anos de experiência. Claro, é seguro dizer que os desenvolvedores seniors são mais qualificados do que os desenvolvedores juniors e plenos.
Mas o conhecimento não é o fator mais importante. Desenvolvedores seniors escrevem código mais fácil e vêm com uma mentalidade diferente dos desenvolvedores juniors. Mas é mais do que apenas habilidades de codificação. Saber que perguntas fazer e como acompanhar essas questões é essencial. E é algo que apenas o desenvolvedor sênior, com sua vasta experiência, sabe como fazer em todas as situações.

Para crescer como um desenvolvedor júnior, você deve se concentrar em escrever código simples e passar por vários ciclos de desenvolvimento. Para ir de um desenvolvedor de nível pleno a sênior, você deve se concentrar em aprender mais do que apenas corrigir tarefas de rotina. Você deve estar disposto a assumir as tarefas mais difíceis e ser um mestre de sua pilha de tecnologia.

Outra responsabilidade de um desenvolvedor sênior é ser o ponto de partida para desenvolvedores menos experientes.

Deixarei uma citação de Martin Fowler: “Any fool can write code that a computer can understand. Good programmers write code that humans can understand.” (*“Qualquer idiota pode escrever um código que um computador possa entender. Bons programadores escrevem código que os humanos podem entender *).

Gostou do conteúdo? não deixe de seguir a uebile nas redes sociais, pois toda semana tem post novo aqui no blog com mais dicas para o seu impulso digital.