Você pode fazer implantação contínua com programadores juniores?

Há um momento em que você começa a entender que, na arquitetura de microsserviços, é mais assustador esperar uma semana para implantar todos os microsserviços de uma só vez, para garantir que tudo funcione em conjunto, do que impor rigorosamente o versionamento da API, escrever muitas testes (um pouco de cada: unidade e exploratório, integração) e implantação automática na produção assim que sua confirmação passar como testes no palco.

Agora, parece uma ótima idéia, desde que você se lembre de escrever testes, testar as alterações antes de confirmar, saber usar o versionamento da API e não descartar o banco de dados no script de atualização incremental de db executado na implantação (que não é um grande problema, pois deve falhar no palco).

Mas é possível fazê-lo com programadores juniores? Talvez eu precise implementar o esquema de solicitação de recebimento. Isso tornaria menos a implantação contínua (esse é o meu palpite)?

Espero que isso não seja baseado em opiniões e posso contar com você compartilhando sua experiência, obrigado.

Observe que não estou perguntando sobre o IC nem sobre a entrega contínua. Nós já temos isso. O que estamos tentando agora é implementá-lo continuamente, o que significa ter tudo em produção logo após o check-in do código.

Por que não? Qualquer uma das coisas que você descreve seria um problema, independentemente de você usar a implantação contínua ou não. O problema, ao que parece, é que você está preocupado com o fato de os juniores cometerem um erro catastrófico. E que esse erro será levado à produção antes que alguém possa detectá-lo.

É por isso que você faz revisões de código e testes. Antes que qualquer coisa seja mesclada em sua ramificação principal e prevista para lançamento, exija que seja revisada pelo código, por alguns outros juniores (para que eles tenham experiência) e por desenvolvedores seniores (para usar seus conhecimentos para melhorar o código). Todo mundo deveria estar procurando por esses erros catastróficos. E deveria detê-los. Caso contrário, você provavelmente precisará de um melhor controle de qualidade / teste em um ambiente de teste (e talvez de alguns desenvolvedores melhores se as análises de código não entenderem isso).

A implantação contínua funcionará bem se você tiver um bom conjunto de testes automatizados.

Os desenvolvedores juniores podem se empolgar com sua própria tarefa e não vêem que eles resolvem tudo. Você pode corrigir isso com alguma automação. Configure um servidor de compilação que executará testes o tempo todo e obtenha uma ferramenta como o notificador de compilação CatLight . Isso dará a eles um feedback rápido e claro quando eles quebrarem as coisas.

Eles corrigem pequenos problemas à medida que acontecem e mantêm sua entrega contínua em execução.

A única maneira de aprender bons hábitos é praticá-los; portanto, os desenvolvedores juniores também podem praticar a implantação contínua. Você pode pensar em adicionar etapas ao pipeline para fazer coisas como verificar a cobertura do teste e, possivelmente, executar uma análise estática do código e falhar na construção se a cobertura do teste não for alta o suficiente. Isso garantirá que os desenvolvedores juniores compreendam as expectativas antes que algo seja considerado completo.

Não apenas você pode fazer isso com desenvolvedores juniores, mas também é necessário. Primeiro, você reduzirá a qualidade do software, caso contrário, ajudará os desenvolvedores juniores a aprender boas habilidades de desenvolvimento de software.

Como analogia: você gostaria que seu médico não praticasse a medicina da melhor maneira possível, porque ele tem medo de erros de aprendizagem? Como os médicos lidam com os possíveis danos?

De experiências anteriores com uma base de código do Big Ball Of Mud que evoluiu naturalmente ao longo de muitos anos nas mãos de muitos desenvolvedores juniores não supervisionados, gostaria de salientar o que acontece quando você não pratica CI com esses desenvolvedores.

Editar / Atualizar : conforme comentário de RubberDuck; Esta resposta assume que seu destino de mesclagem para integração é um ramo de desenvolvimento, em vez de um ramo de avaliação ou liberação.

• Obviamente, precisa haver muito mais controle sobre o código para lançamento e implantação ao vivo; se não houver uma ramificação de produção separada, vale a pena considerar uma alteração em sua estratégia de ramificação / mesclagem para executar uma ramificação de desenvolvimento principal (usada para teste de integração e nunca para liberação) juntamente com a ramificação de liberação principal. Isso mantém todos os benefícios do CI e mesclagens frequentes sem arriscar quebrar o código de produção.

1. Os desenvolvedores juniores são menos propensos a se comunicar com seus colegas de trabalho ou supervisor

A integração contínua não é simplesmente uma questão de mesclar código, é um momento no qual um desenvolvedor é forçado a interagir com outras partes interessadas.

A comunicação é importante e, sem querer generalizar demais, tende a ser uma habilidade aprendida que chega menos naturalmente aos desenvolvedores inexperientes do que àqueles que estão acostumados a trabalhar em um ambiente de equipe.

Se você permitir que os desenvolvedores juniores permaneçam em seu cubículo e joguem fora o código por semanas sem serem solicitados relatórios / análises frequentes, é mais provável que evitem completamente a comunicação.

2. O código que eles estão produzindo provavelmente precisará de uma revisão mais rigorosa

Você já revisou algo tão ruim que desejou ter buscado antes e impedido de ter sido escrito? Isso acontece muito.

Você não pode impedir que um código incorreto seja gravado, mas pode limitar o tempo perdido. Se você se comprometer a análises e mesclagens frequentes, minimiza o escopo por tempo perdido.

O pior cenário é que você pode deixar um desenvolvedor júnior sozinho por várias semanas em seu próprio projeto em miniatura e, quando ele estiver finalmente pronto para a revisão do código, simplesmente não haverá tempo suficiente para ele jogar toda a bagunça. longe e comece novamente do zero.

Muitos projetos se tornam uma grande bola de barro simplesmente porque toda uma carga de código incorreto foi escrita quando ninguém prestava atenção até que fosse tarde demais.

3. Você deve ter menos certeza de que um desenvolvedor júnior ou outro novo membro da equipe entendeu os requisitos

Às vezes, um desenvolvedor pode criar a solução perfeita para o problema errado; este é triste porque geralmente se resume a simples mal-entendidos que seriam tão fáceis de evitar se alguém tivesse feito a (s) pergunta (s) correta (s) no início do processo.

Novamente, esse é um problema que provavelmente afetará desenvolvedores inexperientes, com maior probabilidade de aceitar requisitos "ruins" pelo valor nominal, em vez de recuar e questionar a sabedoria do requisito.

4. É provável que eles estejam menos familiarizados com padrões comuns, com a arquitetura do código existente e com ferramentas e soluções conhecidas

Às vezes, um desenvolvedor gasta muito tempo reinventando a roda desnecessariamente, simplesmente porque não sabia que existia uma solução melhor. Ou eles podem passar dias tentando martelar uma estaca quadrada em um buraco redondo sem perceber o que estão fazendo de errado.

Novamente, é mais provável que esse tipo de coisa ocorra com desenvolvedores inexperientes, e a melhor maneira de resolver o problema é garantir revisões regulares.

5. Longos períodos entre as confirmações / mesclagens de código tornam os defeitos mais difíceis de identificar e corrigir

Quando um bug surge imediatamente após várias semanas de alterações no código terem sido mescladas no ramo principal, o desafio de identificar qual alteração pode ter causado o bug fica mais difícil.

Obviamente, sua estratégia geral de ramificação também entra em jogo aqui; idealmente, todos os seus desenvolvedores trabalharão em suas próprias ramificações ou dentro das ramificações de recursos (ou ambos) e nunca funcionarão diretamente fora do mestre / tronco.

Vi situações em que equipes inteiras estão trabalhando diretamente no mestre / tronco ao mesmo tempo, e esse é um ambiente terrível para o CI, mas felizmente a solução de afastar todos do mestre / tronco geralmente fornece estabilidade suficiente para o trabalho individual itens / bilhetes / etc.

Sempre deve ser "bom" para qualquer desenvolvedor interromper a ramificação mestre / tronco, com o entendimento de que a mesclagem deve ocorrer regularmente, que as alterações e defeitos de quebra devem ser identificados mais rapidamente e, portanto, resolvidos mais rapidamente. Os piores defeitos são tipicamente aqueles que permanecem despercebidos por meses ou até anos.

Em suma; As principais vantagens da integração / implantação contínua são:

• A comunicação entre sua equipe melhora
• A qualidade do código geralmente é mantida em um padrão mais alto
• É menos provável que os requisitos sejam perdidos ou mal interpretados
• Os problemas de arquitetura e design devem ser detectados mais rapidamente,
• É mais provável que os defeitos sejam detectados e corrigidos em um estágio anterior

Portanto, se você não pratica o IC com seus desenvolvedores juniores, está aceitando muitos riscos desnecessários significativos, pois esses são os membros da sua equipe que precisam mais do que o resto.

Sim, você pode praticar o IC com desenvolvedores juniores. Seria estúpido não no atual clima de desenvolvimento. É incrivelmente útil poder pressionar para reposicionar e depois mesclar automaticamente o código de teste - e assistir tudo em tempo real no Travis (ou Bamboo, Pipelines etc ...)!

Leve o seu cara do DevOps e peça para ele passar pelo processo com eles, além de um desenvolvedor sênior em espera apenas para vigiar as coisas e vinculá-lo às resenhas de códigos (você faz isso, certo?)

Se você se preocupa com o fato de o código não ser aprovado, isso não está no CI e não está nos juniors: está em você .

Portanto, ajude-os a melhorar e se acostumar a implementar o código do estágio / produto mais rapidamente. Você se agradecerá a longo prazo.