Desenvolvedores bloqueados esperando o código ser mesclado de outro ramo usando o GitFlow

Nossa equipe acabou de mudar de FogBugz & Kiln / Mercurial para Jira & Stash / Git. Estamos usando o modelo Git Flow para ramificação, adicionando ramificações de subtarefa fora das ramificações de recurso (relacionadas às subtarefas Jira dos recursos Jira). Estamos usando o Stash para atribuir um revisor quando criamos uma solicitação pull para mesclar novamente para a ramificação pai (geralmente desenvolvemos, mas para subtarefas de volta para a ramificação de recursos).

O problema que estamos descobrindo é que, mesmo com o melhor planejamento e detalhamento dos casos de recursos, quando vários desenvolvedores estão trabalhando juntos no mesmo recurso, digamos no front-end e no back-end, se estão trabalhando no código interdependente que é em filiais separadas, um desenvolvedor acaba bloqueando o outro.

Tentamos puxar entre os galhos um do outro à medida que desenvolvemos. Também tentamos criar ramificações de integração local que cada desenvolvedor pode obter de várias ramificações para testar a integração à medida que elas se desenvolvem. Finalmente, e isso parece funcionar possivelmente o melhor para nós até agora, embora com um pouco mais de sobrecarga, tentamos criar um ramo de integração fora do ramo de recursos logo de cara. Quando um ramo de subtarefa (fora do ramo de recurso) está pronto para uma solicitação de recebimento e revisão de código, também mesclamos manualmente esses conjuntos de alterações nesse ramo de integração de recursos. Todos os desenvolvedores interessados ​​podem extrair desse ramo de integração para outros ramos de subtarefa dependentes. Isso impede que alguém espere por qualquer filial da qual eles dependam para passar na revisão de código.

Eu sei que isso não é necessariamente um problema do Git - tem a ver com o trabalho no código interdependente em várias ramificações, misturado com nosso próprio processo de trabalho e cultura. Se não tivéssemos a política estrita de revisão de código para o desenvolvimento (verdadeiro ramo de integração), o desenvolvedor 1 poderia se unir para desenvolver o desenvolvedor 2. Outra complicação é que também é necessário que você faça alguns testes preliminares como parte do processo de revisão de código antes de entregar o recurso ao controle de qualidade. Isso significa que, mesmo que o desenvolvedor de front-end 1 esteja saindo diretamente da ramificação do desenvolvedor de back-end 2, eles se o desenvolvedor de back-end 2 terminar e sua solicitação de recebimento estiver em revisão de código por uma semana, então o desenvolvedor de front-end 2 tecnicamente não poderá criar sua solicitação / revisão de código porque seu revisor de código não poderá teste porque o desenvolvedor de back-end 2 '

Resumindo, estamos nos encontrando em uma abordagem muito mais serial do que paralela nesse caso, dependendo de qual rota seguirmos, e gostaríamos de encontrar um processo a ser usado para evitar isso.

A última coisa que mencionarei é que percebemos compartilhando código entre filiais que não foram revisadas e finalizadas, mas ainda estamos usando o código beta de outras pessoas. Até certo ponto, acho que não podemos evitar isso e estamos dispostos a aceitar isso até certo ponto.

O problema também pode estar em uma separação de tarefas muito rígida entre o desenvolvimento de back-end e front-end.

Se um desenvolvedor front-end precisa de uma nova API, não é possível permitir que ele crie uma API fictícia no back-end (retornando sempre o mesmo valor, por exemplo) para validar o layout? Em seguida, confirme essa implementação parcial com um stub e, pela segunda vez, um desenvolvedor de back-end implementará o recurso real.

Ao quebrar a dependência, você obterá um fluxo melhor e não precisará parar tudo aguardando uma única tarefa que atue como gargalo.

Seu problema: ramificações do desenvolvedor A da Master, ramificações do desenvolvedor B da Master, ambas trabalham em recursos intimamente relacionados, e o fato inevitável de que as mesclagens na ramificação da Master são difíceis por causa de conflitos inevitáveis ​​é o que impede todos.

Se isso for previsível, então A e B poderão primeiro criar uma ramificação comum, então cada ramificação para seu trabalho separado dessa ramificação comum, mesclar cada um de seu trabalho separado na ramificação comum e agora você tem uma ramificação livre de conflitos que é muito mais fácil de integrar.

Se o desenvolvedor 1 trabalha no recurso A e o desenvolvedor 2 finaliza o trabalho no recurso B que depende do recurso A, não há como evitar - a fusão do recurso B está em espera. Você não pode testá-lo sem o recurso A, e não faz sentido revisá-lo ainda, pois um progresso maior no recurso A pode levar a alterações no recurso B.

Isso não significa, no entanto, que o desenvolvedor 2 esteja em espera! O desenvolvedor 2 pode começar a trabalhar no recurso C e retornar ao ciclo de correção e revisão do recurso B quando o recurso A estiver concluído. Eu sei que a alternância de contexto não é o ideal, mas desde o tempo que vai demorar a funcionalidade completa A é provavelmente medido em dias não é que ruim (você não está puxando-os para fora de "The Zone" para um 15 minutos side-tarefa)

Uma coisa que você pode fazer para ajudar a situação é dar uma boa olhada em maneiras de diminuir o ciclo de desenvolvimento.

No caso de um desenvolvedor aguardar um recurso de outro desenvolvedor, existe uma maneira de uma parte dos primeiros desenvolvedores trabalhar passar por revisão e integração antes de todo o recurso para liberar o bloco?

Existem maneiras de dividir os recursos em unidades de trabalho menores para manter o ciclo de integração?

Além disso, quanto tempo leva a integração? Se houver uma longa reviravolta em uma construção ou integração, isso pode atrasar toda a fila. Veja se há algo que você pode fazer para acelerar o tempo de compilação, para que as filas sejam liberadas mais rapidamente.