Estratégia de ramificação para ambiente de teste

Iniciaremos um novo projeto este mês. O projeto será de 1 ano e a implantação da produção ocorrerá apenas no final do projeto.

Faremos o desenvolvimento iterativo (1 mês por iteração); portanto, deixaremos os recursos para o ambiente de teste no final de cada iteração para o teste de controle de qualidade.

Nossa estratégia de ramificação é:

1. Tronco - Todo o desenvolvimento acontecerá no tronco.
2. Ramificação de recursos - As ramificações do tronco serão criadas conforme a necessidade para o desenvolvimento de grandes recursos que poderiam ser interrompidos se realizados no tronco
3. Ramificações de liberação do controle de qualidade - No final de cada iteração, uma ramificação do tronco será criada. Essa ramificação (que inclui um número de versão) será lançada no ambiente de teste. Todos os erros críticos e de bloqueio encontrados nesta versão serão corrigidos nesta ramificação e as correções precisarão ser mescladas ao tronco. Bugs não críticos / triviais não serão tratados na ramificação de liberação do controle de qualidade e serão corrigidos apenas no tronco, pois a ramificação de liberação do controle de qualidade será descartada após o final da próxima iteração, em que uma nova ramificação de liberação será criada fora do tronco.
4. Ramo de produção - este será o último ramo de liberação do controle de qualidade no final do projeto. Isso será marcado e todas as correções de erros de produção estarão neste ramo e mescladas ao tronco.

Essa é uma estratégia de ramificação correta? Falta considerar algo mais?

Estamos usando o SVN.

Sua estratégia de ramificação parece realmente boa para mim. Eu fiz a mesma estratégia no passado e funciona bem. Desenhe-o em um quadro branco e faça com que todos os seus desenvolvedores o entendam, para que as pessoas façam o trabalho certo no ramo certo. Ensine e explique a todos o comando switch e faça com que todos checem novamente o ramo em que estão trabalhando. (Ou, alternativamente, basta conferir o repositório inteiro ... dependendo do tamanho do seu código :) Lembre-se ... svn revert é seu melhor amigo!

Pessoalmente, prefiro que uma pessoa seja a pessoa "mesclar / ramificar" (com algumas pessoas de reserva como reserva) para garantir que tudo seja mantido sob controle e consistente. Deixe essa pessoa se tornar seu guru SVN e você estará fora.

Algumas outras dicas úteis:

• Incentive atualizações frequentes do SVN e confirmações do SVN. Todo dia é preferível.
• Mesclagens entre ramificações também devem ser feitas todos os dias ou, alternativamente, sempre que um bug for corrigido. Faça-os cedo e faça-os frequentemente! (você ficará bom nisso rapidamente).
• Obtenha uma boa ferramenta de comparação - além da comparação é o ás. O tortoiseSVN padrão ... não é muito bom.
• Não faça check-in de coisas que mudam durante a compilação (como o diretório de saída)
• Tente limpar seu repositório antes de começar a ramificação (livre-se de arquivos que não precisam estar sob controle de versão - coisas como bibliotecas externas etc.). Quanto menor o seu repo, melhor
• As alterações no ramo de produção e no controle de qualidade devem ser as menores e menores possíveis - não comece a refatorar o código lá, apenas corrija o erro.
• Certifique-se de ramificar do nível superior da sua solução - e se você tiver um banco de dados, espero que tenha escrito todos os seus scripts (como procs ou gatilhos armazenados)

Diga também às pessoas para não moverem as pastas, a menos que seja estritamente necessário. Isso tornará a sua fusão muito mais fácil :) (Não faça o que eu fiz, inicie uma enorme reestruturação de diretório na metade de uma grande mudança no tronco que estragou todas as nossas fusões ... Eu fiquei bastante popular depois disso).

Parece uma ideia que pode não funcionar.

Talvez dê uma olhada neste link para obter alguma inspiração: Fluxo do GitHub É assim que o github está usando seu sistema de versões. Mesmo que eles usem git em vez de svn, eu argumentaria que as idéias por trás de suas decisões serão válidas.

As (imho) partes mais importantes desta postagem de blog relacionadas ao controle de versão:

• mestre / tronco é implantável ou - melhor ainda - implantado
• desenvolvimento acontece apenas em filiais
• a fusão ocorre somente após a revisão (talvez você possa fazer o controle de qualidade aqui)

Dessa forma, você obtém estabilidade. Deixe-me explicar o porquê. Você precisa de alguma base para se ramificar. Agora, se essa base não é a melhor que você pode fazer e a instância final de tudo, não faz muito sentido fazê-lo. Se você se ramificar do tronco enquanto outros trabalham nele, você verá bugs que eles introduzem que ainda não foram encontrados ou corrigidos. Portanto, os prováveis ​​testes de integração (e qualquer coisa acima) podem falhar, mesmo que você não seja a causa, aumentando drasticamente a quantidade de depuração e frustração.

Além disso, você terá muito trabalho mantendo seus 3 ramos (tronco, controle de qualidade, produção) sincronizados. Isso provavelmente levará a confusão. Eu quase posso garantir que você perca o controle em algum momento, se você não aplicar isso com automação.

Eu sugeriria seguir o caminho do GitHub. Em seguida, você pode marcar a versão que envia ao controle de qualidade para ter uma referência ao se comunicar. Ainda melhor poderia ter QA mais apertado integrado no ciclo de feedback como indicado acima. Eu sugiro usar um sistema de IC como o Jenkins, se você ainda não pensou em usá-lo. Dessa forma, você minimiza o tempo de ida e volta entre o check-in e o feedback e pode impor regras de codificação, executar analisadores estáticos para verificação de erros e assim por diante.

Isenção de responsabilidade: o fluxo git funciona apenas se você não deseja corrigir bugs sem introduzir novos recursos. Se você quiser fazer isso, sua abordagem pode ser mais adequada.

Sua estratégia de ramificação me parece bastante razoável. Buscamos uma estratégia semelhante na minha empresa e ela funcionou bem conosco.

Uma pequena diferença é que fazemos correções de controle de qualidade pré-lançamento no tronco, porque isso impede que tenhamos que voltar atrás e não tivemos realmente um problema com o desenvolvimento de novos recursos enquanto corrigíamos defeitos. Isso dá ao controle de qualidade um alvo mais móvel em termos do que eles estão testando; portanto, como isso é viável depende de quão bem integrado é o controle de qualidade com a equipe de desenvolvimento. Funciona bem para nós porque temos uma equipe bastante integrada e porque estamos em um cronograma de iteração rápido. Temos uma ramificação separada para cada versão, para que possamos corrigir o ambiente de produção enquanto ainda criamos novos recursos no tronco, mas isso não parece necessário para você mais tarde, quando você começar a liberar além do controle de qualidade.

Há algumas recomendações adicionais que eu faria:

1. Incentive check-ins frequentes. Isso é especialmente útil se você tiver muitas pessoas desenvolvendo no tronco. Isso impedirá que os desenvolvedores fiquem fora de sincronia com o que os outros estão fazendo e reduzirá o potencial de conflitos. Verifique se há orientações explícitas sobre quando é aceitável confirmar e com que frequência os desenvolvedores devem estar recebendo do tronco. As confirmações frequentes não devem ser um problema, pois você está tentando isolar as alterações de interrupção nas ramificações dos recursos.
2. Instale um processo de integração contínua. Isso garante ainda mais que você não tenha grandes dores de cabeça de integração no final de uma iteração, forneça uma notificação se houver alguma falha e permita que você automatize mais seu controle de qualidade por meio de testes automatizados de unidade / aceitação e, potencialmente, por análise / código estático ferramentas de inspeção. Descobri que o CI fornece um excelente retorno financeiro como investimento no processo de gerenciamento de configuração. Nota, existe uma tensão entre o IC e o uso de ramificações de recursos porque os ramos essencialmente permitem manter o tronco limpo, passar nos testes no CI, mas ainda criar conflitos / problemas nos ramos. Mesclagens freqüentes de volta ao tronco podem ajudar com isso, assim como executar o IC na ramificação e retirá-lo com freqüência, mas uma proliferação de ramificações começará a derrotar o processo do IC, complicando sua administração ou simplesmente ignorando-a nas ramificações.

Pelo que você declara:
Seu código reside no tronco
Para cada recurso / aprimoramento principal - você corta um ramo do tronco - desenvolva e forneça ao controle de qualidade para testar
Todos os bugs importantes e importantes são corrigidos neste
tronco de ' ramo de controle de qualidade' Pós-controle de qualidade 'o código deste ramo de volta ao tronco

Isso me parece uma estratégia bastante aceitável:
temos ramificado, mesclado e entroncado regularmente no SVN usando o eclipse svn plugin ou tartaruga
Parece bom para mim

Parece bom, eu me preocuparia que o ramo de controle de qualidade tenha vida útil relativamente curta, e eu faria todas as correções relacionadas a esse lançamento nesse ramo, para que eles sejam mesclados ao tronco de uma só vez, em vez de corrigi-los no tronco à medida que são encontrados .

Se você corrigir os erros triviais na ramificação do controle de qualidade, os testadores poderão ver e marcá-los rapidamente. Suponho que eles recebam compilações diárias / semanais do ramo do controle de qualidade, portanto, erros triviais não devem consumir muito tempo se forem feitos no controle de qualidade. (Falo por experiência em que o menor dos minúsculos insetos pode ter um efeito indireto que causa grande sofrimento em outros lugares)

Uma melhoria em potencial que eu poderia mencionar é fazer o desenvolvimento de recursos em uma filial - ou seja, mover o trabalho que você costuma fazer no tronco para uma filial dedicada. Em seguida, o tronco terá apenas fusões confirmadas, o que pode ajudar no rastreamento de alterações concluídas.

Você mencionou várias coisas que provavelmente aumentam o constrangimento e reduzem as chances de sucesso do seu projeto:

O projeto será de 1 ano e a implantação da produção ocorrerá apenas no final do projeto.

Eu realmente recomendo que você implante em um ambiente de produção o mais rápido possível, idealmente todos os dias. Deixar a chamada 'produção' até o final do projeto geralmente resulta em problemas imprevistos. Os anti-padrões aqui são 'integração tardia' e 'implantação tardia da produção'.

1 mês por iteração

Um mês é uma pulsação muito longa da iteração, e poucos desenvolvedores poderão se lembrar claramente do que estavam trabalhando no início da iteração. Eu recomendo ir para iterações de 2 semanas, entregando em lotes menores. Anti-padrões: 'lotes grandes', 'tempo de ciclo longo'.

Filial de Recursos

Você provavelmente deve evitar ramificações de recursos, a menos que também use ramificações de integração . Idealmente, use alternâncias de recursos e ramificação por abstração. A ramificação de recursos tende a levar a problemas inesperados de integração tardia. Anti-padrão: 'integração tardia'.

Estamos usando o SVN.

A fusão é bastante dolorosa no Subversion, mesmo se você usar os recursos de rastreamento de mesclagem da v1.5 e posterior. Eu recomendo que você mude para o Git - você nunca olhará para trás. Mesclar com o Git é indolor comparado com o Svn. Eu usei o Subversion por muitos anos e fiquei inicialmente cético em relação ao Git, mas agora estou 'vendido'. As únicas coisas que eu usaria o Svn para o Git são o armazenamento de arquivos binários (se realmente necessário!) E coisas como o RANCID, que estão no controle completo do repositório. Para controle de código fonte, o Git sempre vence o Subversion.

Recentemente, escrevi sobre o trabalho que desenvolvi ao liberar do tronco / linha principal / mestre e evitar ramificações de recursos, o que pode lhe dar um pouco mais de reflexão: Deixando a plataforma - Ramificação e liberação para subsistemas independentes

Além disso, leia algumas postagens no site de Martin Fowler, como ContinuousIntegration , FeatureBranch e BranchByAbstraction .

Por fim, compre uma cópia de Entrega contínua de Jez Humble e David Farley e trabalhe com as recomendações - é um livro extremamente valioso, e todo desenvolvedor deve possuir uma cópia. Eu achei útil imprimir as páginas de Conteúdo e colocá-las na parede para acompanhar o progresso :) Mesmo que você não pretenda entregar continuamente, muitas das práticas deste livro são realmente saudáveis ​​e vitais para uma entrega bem-sucedida de software hoje.

Espero que isto ajude.

M