Idosos e juniores – O’Reilly

Quase parece pejorativo, não é? Mas a distinção entre desenvolvedores de software sênior e júnior é incorporada em nossos empregos e cargos. Seja chamamos de nível de entrada ou outra coisa, distinguimos entre pessoas que estão apenas começando suas carreiras e aquelas que já existem há algum tempo. Ainda estamos aprendendo (esperanças), mas as pessoas de nível básico ainda estão aprendendo o básico, e os idosos têm maior responsabilidade, juntamente com o potencial de cometer erros maiores. Os desenvolvedores de nível básico podem fazer alguma programação básica, mas seu conhecimento não é necessariamente profundo ou amplo. À medida que se mudam para a força de trabalho, precisam aprofundar seus conhecimentos e se tornar parte de uma equipe que escreve um sistema de software para um cliente pagador. Essa nova função requer o desenvolvimento de um novo conjunto de habilidades.

As habilidades para os desenvolvedores de software júnior e sênior variam tremendamente, mas existem alguns temas comuns. Para um desenvolvedor júnior, esperamos:

Aprenda mais rápido. Cavar mais fundo. Veja mais longe.

Familiaridade com uma ou duas linguagens de programação e suas bibliotecas mais importantes
Familiaridade com um pequeno número de algoritmos básicos
Familiaridade com um sistema operacional do lado do servidor
Familiaridade com ferramentas comuns, como git
Experiência limitada trabalhando com equipes, no contexto de projetos de pequenos grupos

Obviamente, os indivíduos também variam tremendamente, de programadores autodidatas que fizeram contribuições substanciais para projetos de código aberto para estagiários de treinamento que podem não entender a diferença entre JavaScript e React. No entanto, se somos honestos sobre as habilidades que esperamos de um desenvolvedor júnior, esta lista mostra aproximadamente o que esperávamos, não a experiência de cinco anos escrevendo SQL.

Para desenvolvedores seniores que esperamos:

Familiaridade com os idiomas em uso em suas empresas e profundo conhecimento de pelo menos um
A capacidade de começar com um novo idioma de programação em dias
Experiência em trabalhar com equipes, grandes projetos e software Legacy
Experiência em compreensão dos requisitos corporativos
A capacidade de orientar funcionários mais novos
Conhecimento completo do ambiente de ferramentas
Habilidades de depuração graves
A capacidade de tomar responsabilidade Para decisões importantes

Os idiomas realmente não são o núcleo da ciência da computação. Mas eles são uma necessidade. Eles são uma maneira de dizer a um computador o que fazer. Dentro dos limites, as linguagens de programação são todas semelhantes. Sim, eu ouço gritos, especialmente dos advogados da programação funcional – e concederei que existem duas ou três classes principais de linguagens de programação e que todo idioma expressa certas idéias importantes sobre o software de escrita. Para um desenvolvedor sênior, porém, nos preocupamos menos com uma longa lista de idiomas do que familiaridade com as idéias. Vemos a mesma coisa com as línguas humanas: depois de aprender uma língua estrangeira, aprender um segundo é mais fácil e um terceiro ou quarto é ainda mais fácil. Você entende como as línguas funcionam. O idioma em si não é tão importante quanto aprender a aprender rapidamente. Os programadores seniores também conhecem o profundo segredo das linguagens de programação: eles são tanto sobre se comunicar com os seres humanos quanto se comunicar com máquinas. O computador não conhece C ++ e não se importa se o software foi escrito em Java, Haskell ou Basic; Não importa como o software seja escrito, ele executará o código da máquina binária. Os seres humanos precisam entender o que seus programas estão dizendo a um computador para fazer, porque tudo o que você escrever agora precisará ser mantido por alguém mais tarde.

E os algoritmos? É importante aprender sobre diferentes algoritmos de classificação, por exemplo? A classificação é importante, mas não pelas razões que um desenvolvedor júnior pode pensar; Quase ninguém precisará implementar um algoritmo de classificação, exceto como um exercício. A classificação é importante porque é fácil de descrever e possui muitas soluções diferentes, e cada solução possui propriedades diferentes. As soluções representam diferentes abordagens para a solução de problemas. Os programadores podem não precisar saber como classificar, mas todo programador precisa entender como resolver problemas com “dividir e conquistar”, como usar a recursão, como estimar o desempenho, como operar em uma estrutura de dados sem criar uma nova cópia – há todo tipo de técnicas e idéias incorporadas na classificação que um programador realmente tem a saber. Pensando que esse tipo é desnecessário apenas porque uma função Sort () está nas bibliotecas de todas as idiomas é, bem, um sinal de um programador júnior que nunca se tornará mais nada.

Idiomas e algoritmos são apostas de tabela; Eles não são as marcas distintivas de um desenvolvedor sênior. Esperamos que um desenvolvedor sênior tenha conhecimentos mais amplos e mais profundos – mas o que torna um desenvolvedor sênior é todo o resto da lista: trabalho em equipe, a capacidade de trabalhar em grandes projetos, entender os requisitos da empresa, a orientação e muito mais que não listamos. Podemos resumir dizendo “experiência”, mas isso não é realmente útil. O que a experiência ensina? A experiência começa com o reconhecimento de que a programação não é fundamentalmente sobre linguagens de programação. As linguagens de programação são necessárias, mas os idosos sabem que a essência da programação é solução de problemas: entender os problemas e descobrir como resolvê-los de maneiras estruturadas e repetíveis. Como disse o professor de ciência da computação de Stanford, Mehran Sahami conversa com Andrew Ng,¹ “Nós ensinamos a você o Python, mas realmente estávamos tentando fazer com que você entenda como tomar problemas e pensar sobre eles sistematicamente”.

Os idosos também reconhecem que o entendimento dos problemas não está apenas criando um algoritmo. É entender quem deseja o problema resolvido, por que eles querem resolver, quem está pagando pelo problema a ser resolvido, que partes do problema já foram resolvidas, que tipos diferentes de soluções são possíveis, se essas soluções podem ser dimensionadas ou estendidas – e muito mais. Os projetos de software sempre têm um passado e um futuro, e quase sempre têm um componente político. Um desenvolvedor sênior entende que o projeto atual deve se envolver com as soluções do passado e se preparar para os problemas e soluções do futuro. Esperamos que um desenvolvedor júnior faça um trabalho útil em uma pequena parte de um grande projeto; Esperamos que um veterano entenda esses problemas maiores: lutar com a história do projeto e garantir que seja mantido no futuro.

Os desenvolvedores seniores também exercem liderança, embora não precise ser formal. Além de liderar formalmente um grupo, a liderança inclui orientação, trabalho bem com as equipes, sendo a voz da razão quando as coisas são aquecidas, tomando decisões difíceis e tendo conhecimento amplamente conhecedor do ambiente da organização: quais são as ferramentas? Quais recursos estão disponíveis? Quais são a política organizacional? Um líder é alguém que os membros da equipe vão com perguntas.

Os desenvolvedores seniores têm habilidades técnicas suecidas que vão além da capacidade de adquirir novas linguagens de programação rapidamente. Talvez seja um mito, mas os desenvolvedores experientes parecem ter a capacidade de olhar para algum código de buggy e dizer: “isso parece suspeito”. Porque eles viram muito, eles sabem o que parece certo e o que não. Eles sabem onde os bugs provavelmente estarão escondendo. Eles resolveram muitos problemas e sabem quais soluções provavelmente funcionarão – e sabem como testar diferentes abordagens.

Um desenvolvedor júnior se torna um desenvolvedor sênior ao longo do tempo, experiência e orientação. Leva o crescimento além das tarefas em sala de aula e projetos de pequenos grupos para trabalhar em software que está em desenvolvimento há anos e ainda estará em desenvolvimento quando você for embora. O desenvolvimento profissional de software quase sempre envolve código legado; A grande maior parte do desenvolvimento de software não está construindo algo novo, mas manter algo que já existe. Você precisa pensar em como qualquer código que você escreve se encaixa no que já está lá e também com o que pode estar lá no futuro; Você tem que pensar em designs e arquiteturas maiores. E isso leva a outra distinção importante: embora os desenvolvedores juniores sejam frequentemente fascinados pela última tendência e pela mais nova estrutura, os idosos conhecem o valor de “tecnologia chata. ”

É importante pensar em juniores e seniores agora, pois os assistentes de codificação orientados para a IA facilitam ainda mais a geração de código. Os assistentes de codificação são valiosos e economizam muito trabalho. Eles dão superpotências de desenvolvedores de software; Eles podem escrever muito código de caldeira repetitivo, código necessário, mas nem divertido nem gratificante. E quando usado corretamente, os assistentes de codificação podem ajudar os desenvolvedores a aprender. Mas eles também podem criar um trabalho desnecessário. Como Nat Torkington escreve:²

Quando os juniores enviam o código que não escreveram, eles precisam aplicar o olhar crítico de um veterano a ele mesmo-ele segue nossas convenções, lida com erros corretamente, é a melhor maneira de resolver esse problema etc. Se o júnior não deve fazer o trabalho mais velho, que o júnior se submetiu que o código de AI mais velho, que não é o mais velho, o que se faz com que o júnior seja o que é o mais velho que o sênior é o mais velho, o que faz o júnior que o junior se submetiu a que o código da AI não é mais velho, o que é o mais velho que o sênior é o mais velho, o que é o mais velho que o júnior é o que se faz com que o sénior seja o mais velho, o que é o mais velho que o júnior é o que se destaca, o que é o mais velho que o júnior é o que se faz com que o sénior seja o sênior. Efetivamente, os juniores que usam IA podem fazer trabalho para idosos.

Portanto, uma conseqüência da codificação orientada à IA é que os juniores precisam fazer o trabalho de um veterano, talvez antes de serem totalmente equipados para fazê-lo. Eles precisam ter um olho no quadro geral, porque não estão apenas avaliando a qualidade de seu próprio trabalho, o que é uma habilidade necessária; Eles estão avaliando o trabalho de um outro (que pode ter um grande O), e isso é a habilidade de um veterano. A parte mais importante da programação não é gerar código. É entender o problema em todo o seu contexto. É isso que os desenvolvedores seniores fazem. E isso nos deixa em algumas conclusões.

Primeiro, ouvimos dizer isso com muita frequência que as empresas não precisam mais de desenvolvedores juniores. Talvez isso seja verdade – mas eles ainda precisam de idosos e sem juniores, de onde virão os idosos? Eles não crescem em árvores ou entram na sua porta prontos para ir. Todo mundo quer desenvolvedores “experientes”; Tem que haver uma maneira de adquirir experiência.

Segundo, o que precisamos para ensinar desenvolvedores juniores para que eles possam se tornar idosos? O aprendizado não é apenas sobre linguagens de programação, bibliotecas e algoritmos. Precisamos ensinar a capacidade de analisar os problemas em um contexto mais amplo, pensar em como o software evolui ao longo do tempo, para se comunicar com outras pessoas e fazer isso como parte integrante de um fluxo de trabalho que inclui assistentes de IA. Como Addy Osmani escreve,³ Os juniores devem “se concentrar na construção dessa mentalidade crítica de avaliação e na compreensão de como usar efetivamente as ferramentas de IA”. Em nossa experiência, os desenvolvedores juniores estão empolgados em aprender a usar a IA de maneira eficaz – mas lembre -se de que isso é um complemento a um conjunto de habilidades, e isso aumenta a lacuna entre juniores e seniores. E os idosos também estão trabalhando para adicionar essas mesmas novas habilidades; A IA é tão nova para eles quanto para o recém -formado – possivelmente mais novo.

Finalmente, os assistentes de codificação são bons em codificação, mas os desenvolvedores de assistentes de codificação prestaram relativamente pouca atenção ao restante do trabalho. Não está claro que eles não podem – já temos algumas ferramentas. A IA é boa em fazer anotações em reuniões, gerar transcrições e resumir. No futuro, a IA certamente poderá fazer mais: ajudar a negociar requisitos, navegar em questões políticas – mas ainda não. E sim, a IA está gradualmente ganhando a capacidade de navegar em grandes bases de código, mas ainda precisamos de seres humanos que saibam como as coisas funcionam e onde os segredos estão enterrados.

Sempre precisaremos de desenvolvedores seniores – então sempre precisaremos de desenvolvedores juniores, juntamente com os caminhos que permitem que os juniores se tornem idosos. À medida que incorporamos a IA em nossos fluxos de trabalho, precisamos ser atenciosos em preservar e manter esses caminhos. Como criamos orientação nos requisitos de trabalho? Como incentivamos novas contratações a olhar para imagens maiores, quando grande parte de nossa cultura (e nossos ambientes profissionais) é construída em torno de escalas de tempo mais curtas e mais curtas? Como ensinamos as pessoas a se tornarem solucionadores de problemas em vez de geradores de código? E como ensinamos os humanos a colaborar – tanto com cada uma quanto com a IA? Esses são os problemas que precisamos resolver.