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

17

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.

lobisomem
fonte
Basta verificar - a revisão do código está sendo feita na mesclagem de tarefas do recurso? e não há revisão de código na mesclagem de recursos para desenvolver?
Depende. Temos uma regra geral de que nenhum caso Jira que corresponda a uma ramificação na qual verificamos código diretamente e que não atua como um caso "guarda-chuva" no sentido de hierarquia leva mais de 2 dias. Portanto, se um caso de recurso demorar <= 2 dias, haverá uma revisão de código para mesclar o recurso a ser desenvolvido. Se houver subtarefas, depois que todas elas forem mescladas em seu ticket de recurso, alguém envia uma solicitação visual para mesclar essa ramificação de recurso no desenvolvimento, mas não no mesmo nível de revisão de código, pois todas as subtarefas já passaram por esse processo.
Fogwolf 28/05

Respostas:

11

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.

Xavier T.
fonte
Eu pensei sobre isso, mas não faz parte do nosso processo de desenvolvimento atual e é uma sobrecarga extra. Eu não acho que o problema seja inteiramente o desenvolvedor front-end, mas não possa acessar o código do desenvolvedor back-end para testar durante o desenvolvimento. É mais sobre os revisores de código fazendo um teste de fumaça de toda a integração (nada que seja ridicularizado ou removido) antes de enviá-lo ao controle de qualidade.
Fogwolf 28/05
6
Embora isso não faça parte do seu processo de desenvolvimento, isso é uma sobrecarga extra do que ter dois desenvolvedores mexendo o polegar por três dias esperando que outra pessoa confirme seu código? Você tem 8 horas perdidas de tempo de desenvolvedor por brincadeira com o polegar. Compare isso com o tempo necessário para remover dependências de back-end.
Greg Burghardt
5

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.

gnasher729
fonte
0

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)

Idan Arye
fonte
Claro, mas esse não é o problema. Trata-se de, para um único recurso, o processo se tornar um pouco mais serializado do que deveria ser. Se estivermos programados para lançar um recurso na data x, e os tickets não puderem ser revisados ​​em paralelo, isso fará com que nossas estimativas sejam desativadas e, potencialmente, empurrando o lançamento.
Fogwolf 28/05
0

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.

Steve Mitcham
fonte
É isso que minhas principais esperanças são. Acho que não podemos eliminar o problema, mas, ao nos familiarizar com o novo fluxo de trabalho, espero que melhoremos o planejamento e detalhamos nosso trabalho de forma colaborativa nesse novo sistema para minimizar o problema. Estava apenas verificando se alguém havia encontrado algo semelhante e se havia algo relacionado ao processo ou ao modelo de ramificação que estamos usando que poderia ajudar. Obrigado.
Fogwolf # 28/14