Prática recomendada com código fonte ramificado e ciclo de vida do aplicativo

Somos uma pequena loja ISV e geralmente enviamos uma nova versão de nossos produtos todos os meses. Usamos o Subversion como nosso repositório de código e o Visual Studio 2010 como nosso IDE. Estou ciente de que muitas pessoas estão defendendo o Mercurial e outros sistemas de controle de fonte distribuída, mas neste momento não vejo como poderíamos nos beneficiar deles, mas posso estar errado.

Nosso principal problema é como manter ramificações e tronco principal em sincronia.

Aqui está como fazemos as coisas hoje:

1. Liberar nova versão (criar automaticamente uma tag no Subversion)
2. Continue trabalhando no tronco principal que será lançado no próximo mês

E o ciclo se repete todo mês e funciona perfeitamente. O problema surge quando um release de serviço urgente precisa ser lançado. Não podemos liberá-lo do tronco principal (2), pois está em desenvolvimento pesado e não é estável o suficiente para ser liberado com urgência.

Nesse caso, fazemos o seguinte:

1. Crie uma ramificação a partir da tag que criamos na etapa (1)
2. Bug fix
3. Teste e liberação
4. Empurre a alteração de volta para o tronco principal (se aplicável)

Nosso maior problema é mesclar esses dois (ramo com principal). Na maioria dos casos, não podemos confiar na mesclagem automática porque, por exemplo:

• muitas mudanças foram feitas no tronco principal
• mesclar arquivos complexos (como arquivos XML do Visual Studio etc.) não funciona muito bem
• outro desenvolvedor / equipe fez alterações que você não entende e não pode simplesmente mesclá-las

Então, o que você acha que é a melhor prática para manter essas duas versões diferentes (branch e main) sincronizadas. O que você faz?

Acho que sua abordagem para ramificação e fusão é boa, mas se o principal problema é que a base de código é bastante instável, é nisso que você precisa se concentrar e minimizar.

A principal coisa a garantir é que a base de código tenha uma boa separação de preocupações . Dependências entre vários componentes precisam ser isoladas e reduzidas. Isso deve resolver a maioria dos seus problemas. Também seguir práticas como o princípio de responsabilidade única ajudará.

Se uma grande mudança na arquitetura precisar ocorrer, ela deve ocorrer em sua própria ramificação e, em seguida, mesclada de volta à principal, uma vez totalmente testada e 'estável' (dentro do razoável). Isso pode ser doloroso e desafiador, mas também deve ser raro. Se você tiver boas práticas de teste, o risco será minimizado.

Também pode ajudar a mudar para um sistema de controle de versão distribuído. Isso deve fornecer um tronco estável, com diferentes recursos mesclados em diferentes ramificações quando estiverem prontos. Você ainda terá problemas de mesclagem se o código for muito interdependente, mas você terá mais controle.

Olhando para isso de outra perspectiva, considere também uma maior comunicação entre sua equipe. Realize reuniões regulares de estilo ágil. Considere onde estão os membros da equipe e como isso pode ajudar. Se uma mesclagem complexa precisar ocorrer, pode não ser uma coisa tão ruim - use uma abordagem de programação em pares que dê entendimento a ambas as partes.

Costumo olhar para isso da maneira oposta:

• O tronco sempre deve ser um código pronto para produção (após seu primeiro lançamento inicial, ou seja).
• Deve haver uma ramificação do tipo desenvolvimento que corre paralela ao tronco, onde seu desenvolvimento mensal acontece. Todo mês, quando chega a hora do lançamento, isso é mesclado no tronco, testado e depois lançado.
• Os hotfixes podem ser facilmente criados no seu tronco e efetuados check-in, e sempre podem ser implantados com sucesso. Em seguida, faça um patch do hotfix e aplique-o ao seu ramo de desenvolvimento.

Obviamente, esse fluxo de trabalho é muito mais adequado para algo que não é SVN, porque uma boa ramificação e mesclagem é algo bastante doloroso no SVN, independentemente do seu fluxo de trabalho. Na minha experiência, a fusão no SVN quase sempre deve ser feita manualmente, porque simplesmente não funciona e não há uma maneira real de contornar isso.

Ultimamente, tenho defendido uma filosofia de "ramificação e mesclagem" como último resultado. Eu acho que é a infeliz verdade que lidar com código se mescla a partir de ramificações não é um problema técnico, mas é uma tarefa que é cognitivamente difícil: eu acho que é simplesmente que o cérebro humano não rastreia detalhes suficientes para facilitar as coisas. Além disso, ainda tenho que ver a ramificação e a fusão realmente funcionar na prática. Depois que o código é ramificado, a experiência me diz que não há nada além de problemas para mesclá-lo novamente.

Uma abordagem disciplinada de liberação no principal funciona bem.

A ramificação SVN não foi projetada para ser flexível. Eu sugeriria que seu primeiro problema está no SVN; passar disso abrirá novas opções.