Característica de estratégia de ramificação do subversion versus lançamento

característica de estratégia de ramificação do Subversion versus lançamento
Obter através da App Store Leia esta publicação em nosso aplicativo!
Melhor estratégia de ramificação ao fazer integração contínua?
Qual é a melhor estratégia de ramificação a ser usada quando você quer fazer integração contínua?
Release Branching: desenvolva no tronco, mantenha um ramo para cada lançamento. Ramificação de recursos: desenvolva cada recurso em uma ramificação separada, apenas funde uma vez estável.
Faz sentido usar essas duas estratégias juntas? Como em, você se ramifica para cada versão, mas você também se ramifica para grandes recursos? Uma dessas estratégias engrena melhor com a integração contínua? Usar integração contínua ainda faz sentido ao usar um tronco instável?
11 Respostas.
A resposta depende do tamanho da sua equipe e da qualidade do seu controle de origem e da capacidade de mesclar conjuntos de mudanças complexas corretamente. Por exemplo, no controle de fonte de ramo completo, como a fusão CVS ou SVN pode ser difícil e você pode estar melhor com o primeiro modelo, enquanto que se usar um sistema mais complexo como o IBM ClearCase e com um tamanho maior de equipe, você poderia ser melhor com o segundo modelo ou uma combinação dos dois.
Eu, pessoalmente, separaria o modelo de ramal de recursos, onde cada característica principal é desenvolvida em um ramo separado, com subdivisões de tarefas para cada mudança feita pelo desenvolvedor individual. À medida que os recursos se estabilizam, eles são mesclados ao tronco, o que você mantém razoavelmente estável e passa todos os testes de regressão em todos os momentos. À medida que você está perto do final do seu ciclo de lançamento e todos os ramos de recursos se fundem, você se estabiliza e se ramifica de um ramo do sistema de liberação no qual você apenas faz correções de bug de estabilidade e backports necessários, enquanto o tronco é usado para o desenvolvimento da próxima versão e você novamente se ramificam para novos ramos de recursos. E assim por diante.
Desta forma, o tronco contém sempre o código mais recente, mas você consegue mantê-lo razoavelmente estável, criando rótulos estáveis ​​(tags) em grandes mudanças e fusões de recursos, os ramos de recursos são desenvolvimento de ritmo rápido com integração contínua e sub-ramos de tarefas individuais podem ser muitas vezes atualizado do ramo de recursos para manter todos os que trabalham no mesmo recurso em sincronia, enquanto simultaneamente não afetam outras equipes trabalhando em diferentes recursos.
Ao mesmo tempo, você tem através do histórico um conjunto de ramos de lançamento, onde você pode fornecer backports, suporte e correções de erros para seus clientes que, por qualquer motivo, permanecem em versões anteriores do seu produto ou mesmo apenas na versão mais recente lançada. Tal como acontece com o tronco, você não configura a integração contínua nos ramos de lançamento, eles são cuidadosamente integrados ao passar todos os testes de regressão e outros controles de qualidade de liberação.
Se por algum motivo dois recursos são co-dependentes e precisam de mudanças feitas um com o outro, você pode considerar desenvolver ambos no mesmo ramo de recursos ou exigir que os recursos agrupem regularmente partes estáveis ​​do código no tronco e depois atualize as alterações de tronco para trocar código entre ramos do tronco. Ou se você precisar isolar esses dois recursos de outros, você pode criar um ramo comum do qual você ramifica esses ramos de recursos e que você pode usar para trocar código entre os recursos.
O modelo acima não faz muito sentido com equipes com menos de 50 desenvolvedores e sistema de controle de fonte sem ramos esparsos e capacidade de fusão adequada como CVS ou SVN, o que tornaria todo esse modelo um pesadelo para configurar, gerenciar e integrar.
Eu acho o tópico realmente interessante, porque eu confio muito nas filiais no meu trabalho diário.
Lembro-me de Mark Shuttleworth, que propõe um modelo sobre manter o ramo principal puro enquanto vai além do CI convencional. Eu postei sobre isso aqui. Como estou familiarizado com o Cruise Control, também bloguei sobre filiais de tarefas e CI aqui. É um tutorial passo a passo explicando como fazê-lo com SCM de plástico. Finalmente, encontrei alguns dos tópicos sobre CI (e potencialmente falando sobre ramificação) no livro de Duvall sobre CI muito interessante também.
Espero que você ache os links interessantes.
Eu pessoalmente acho muito mais limpo ter um tronco estável e apresentar ramificações. Dessa forma, os testadores e afins ficam em uma única "versão" e atualizam a partir do tronco para testar qualquer recurso que seja um código completo.
Além disso, se vários desenvolvedores estiverem trabalhando em recursos diferentes, eles podem ter seus próprios ramos separados, depois fundir no tronco quando terminarem e enviar um recurso para serem testados sem que o testador tenha que alternar para vários ramos para testar diferentes recursos.
Como um bônus adicional, há algum nível de testes de integração que vem automaticamente.
Penso que qualquer uma das estratégias pode ser usada com o desenvolvimento contínuo, desde que você se lembre de um dos princípios fundamentais que cada desenvolvedor comete no tronco / mainline todos os dias.
Eu tenho feito uma leitura deste livro sobre a CI e os autores sugerem que a ramificação por lançamento é a estratégia de ramificação preferida. Eu tenho que concordar. O raciocínio por recurso não faz sentido para mim ao usar o CI.
Vou tentar explicar porque estou pensando assim. Digamos que três desenvolvedores tomem um ramo para trabalhar em um recurso. Cada recurso levará vários dias ou semanas para terminar. Para garantir que a equipe esteja se integrando continuamente, eles devem se comprometer com a filial principal pelo menos uma vez por dia. Assim que eles começam a fazer isso, eles perdem o benefício de criar um ramo de recursos. Suas mudanças não são mais separadas de todas as mudanças do outro desenvolvedor. Sendo assim, por que se preocupar em criar filiais de recursos em primeiro lugar?
O uso de ramificação por versão requer muito menos fusão entre os ramos (sempre é uma coisa boa), garante que todas as alterações sejam integradas o mais rápido possível e (se feito corretamente) garante que sua base de código esteja sempre pronta para ser liberada. O lado negativo para se ramificar pelo lançamento é que você deve ter um cuidado consideravelmente mais cuidadoso com as mudanças. Por exemplo. A refatoração ampla deve ser feita de forma incremental e, se você já integrou um novo recurso que não deseja na próxima versão, ele deve estar oculto usando algum tipo de mecanismo de alternância de recursos.
Há mais de uma opinião sobre este assunto. Aqui está uma postagem de blog que é uma ramificação de recursos pro com CI.
Os ramos de lançamento são muito úteis, e até mesmo absolutamente necessários, se você precisar manter várias versões do seu aplicativo.
Os ramos de recursos também são muito convenientes, especialmente se um desenvolvedor precisa trabalhar em uma grande mudança, enquanto outros ainda lançam novas versões.
Então, para mim, usar ambos os mecanismos é uma estratégia muito boa.
Link interessante do Livro do SVN.
Recentemente, gostei desse modelo ao usar o git. Embora sua pergunta seja marcada como "svn", você ainda pode fazer algum uso disso.
A integração contínua pode, em certa medida, acontecer no ramo "desenvolver" (ou seja o que for que você chamar) neste modelo, embora possuir ramos de recursos longos para lançamentos futuros não o tornem tão rígido quanto a considerar cada mudança acontecendo com o código em algum lugar. A questão permanece, se você realmente quer isso. Martin Fowler faz.
A integração contínua não deve ser qualquer tipo de fator na determinação de sua estratégia de ramificação. Sua abordagem de ramificação deve ser selecionada com base em sua equipe, no sistema em desenvolvimento e nas ferramentas disponíveis para você.
Tendo dito isto .
não há nenhuma razão para que a CI não possa ser usada em ambas as abordagens que você descreve, essas abordagens funcionam bastante bem em combinação, nenhum dos dois trabalha "melhor" do que o outro CI faz todo o sentido com um tronco instável.
Tudo isso foi respondido na quarta pergunta na página da qual você tirou os diagramas: blogs. collab / subversion / 2007/11 / branching-strat /
Enquanto você entender os princípios, você sempre pode reinventar as melhores práticas. Se você não entender os princípios, as melhores práticas irão levá-lo até antes de desmoronar devido a algum requisito externo conflitante.
Leia o link. Uma vez que você obteve o básico, leia o seguinte artigo pelo venerável Henrik Kniberg. Ele irá ajudá-lo a relacionar o Mainline Model com integração contínua.
Quando iniciamos nossa equipe, herdamos uma estratégia baseada em lançamentos do fornecedor que originalmente desenvolveu o sistema ao qual estávamos prestes a se encarregar. Isso funcionou até o momento em que nossos clientes solicitaram que vários recursos desenvolvidos não fossem incluídos em um lançamento (f. y.i.
250k linhas de código,
2500 arquivos, Scrum com XP SDLC).
Em seguida, começamos a olhar para os ramos baseados em recursos. Isso também funcionou por um tempo - como 2 meses até o momento em que percebemos que nosso processo de teste de regressão levaria mais de 2 semanas, o que combinado com a incerteza do que seria lançado criou uma enorme inconveniência.
O último "prego no caixão" de estratégias SC puras veio quando decidimos que deveríamos ter 1. tronco estável e 2. A produção deveria conter BINÁRIOS testados ST, UAT e Regressão (não apenas fonte - pense CC).
Isso nos leva a conceber uma estratégia que seja um híbrido entre as estratégias SC e baseadas em lançamento.
Então nós temos um baú. Todos os sprints nos ramificamos no ramo de sprint (para pessoas não ágeis - um sprint é apenas um esforço de desenvolvimento com caixa de tempo com saída variável com base na complexidade). Do ramo de sprint criamos os ramos de recursos e o desenvolvimento paralelo é iniciado neles. Uma vez que os recursos estão completos e testados pelo sistema, e recebemos a intenção de implementá-los, eles são incorporados ao ramo de sprint - alguns podem flutuar em vários sprints, geralmente os mais complexos. Uma vez que o sprint está perto do seu fim e as características estão completas. nós "renomeamos" o ramo de sprint para "regressão" (isso permite que o CruiseControl o apanhe sem qualquer reconfiguração) e o teste de regressão / integração começa no EAR construído no cc. Quando tudo estiver pronto, ele vai em produção.
Em suma, os ramos baseados em recursos são usados ​​para desenvolver, teste do sistema e funcionalidade UAT. O ramo de sprint (realmente o ramo de lançamento) é usado para mesclar seletivamente os recursos sob demanda e teste de integração.
Agora, aqui é uma questão para a comunidade - obviamente estamos tendo problemas para realizar uma integração contínua devido ao fato de que o desenvolvimento acontece em muitos ramos e a sobrecarga de reconfiguração do CruiseControl. Alguém pode sugerir e orientar?
Do jeito que eu vejo você quer ter um conjunto limitado de ramos onde você pode se concentrar. Uma vez que você deseja testes, métricas de qualidade de código e muitas coisas interessantes para executar com as compilações, ter muitos relatórios provavelmente irá levá-lo a perder informações.
Quando e o que se ramifica, geralmente depende do tamanho da equipe e do tamanho das características que estão sendo desenvolvidas. Eu não acho que haja uma regra de ouro. Certifique-se de usar uma estratégia na qual você possa obter feedback com antecedência / frequência, e isso inclui ter a qualidade envolvida desde o início dos recursos. O bit de qualidade significa que, à medida que você está automatizando à medida que a equipe se desenvolve, se você se ramifica para um grande conjunto de recursos criado por uma equipe, você também deve ter qualidade envolvida na equipe.
ps Onde você obteve as referências da abordagem? - não acha que esses gráficos representam todas as opções.
Atualização 1: expandindo porque eu disse que não é uma regra de ouro. Basicamente, para equipes relativamente pequenas, achei melhor usar uma abordagem que seja uma mistura. Os ramos de recursos são criados se for algo longo e parte da equipe continuará adicionando recursos menores.
Eu acho que as ferramentas que você usa são um grande fator aqui.
Se você estiver usando a subversão, aderindo à opção 1 e soltando as filiais. Se você estiver usando o GIT, a opção 2 funcionará bem para você.

RE: Estratégia de ramificação - Feature vs Release.
Data: 2006-11-08 17:12:34 CET.
Eu não tive nenhum lugar perto do número de respostas que eu esperava dizer.
minha abordagem é horrível.
Talvez isso seja porque é algo que tem sido debatido até a morte.
antes e ninguém quer começar isso de novo. Ou talvez seja porque.
É realmente melhor do que a estratégia de ramificação baseada em lançamento (tentando.
provoque alguma controvérsia aqui :-)
Alguém conhece quaisquer vantagens reais que a abordagem baseada em lançamento tenha.
sobre a forma baseada em recursos?
Alguém sabe como os lançamentos do Subversion são feitos?
De: Gundersen, Richard [mailto: Richard. Gundersen & # 64; london-scottish & # 46; com]
Enviada: quarta-feira, 8 de novembro de 2006 10:07.
Para: usuários & # 64; subversão & # 46; tigris.
Assunto: Estratégia de ramificação - Feature vs Release.
Estamos tendo um grande debate onde eu trabalho sobre se deve ou não usar o.
"release" quot; estratégia de ramificação baseada, ou a "característica" caminho baseado.
Eu sempre trabalhei com o último. Estas são as razões pelas quais:
1) O tronco é sempre estável. Isso sempre simula exatamente o que está acontecendo.
2) Eu faço todo o trabalho novo em uma filial (seja um pequeno.
mudança experimental ou uma nova versão que é essencialmente uma coleção.
de novos recursos). Isto para mim tem as seguintes vantagens adicionais.
uma. Minhas novas alterações não afetam a base de código de produção.
b. Quando o cliente que pediu a mudança X quer que ele fique vivo, eu.
pode fundê-lo no tronco (porque o seu próprio ramo isolado) e.
liberte apenas essa mudança (além do que estava no tronco originalmente). Eu então.
Cometer, marcar, e hey presto, o tronco ainda imita a produção.
exatamente. Com a abordagem baseada em lançamentos, todos cometendo.
diferentes mudanças no tronco, quando um cliente quer mudar X para ir.
Ao vivo, tenho que lhe dizer que pode ir ao vivo, mas tenho que contar para outro.
cliente, porque eu tenho que liberar X, sua mudança Y também deve ir.
viva também. Esta situação pode nunca ocorrer com sistemas que tenham um.
ciclo de vida de lançamento simples, mas quando você está lidando com sistemas grandes.
com diferentes conjuntos de clientes (especialmente se eles tiverem diferentes.
requisitos legais, ou eles estão em diferentes países) eu acho que isso é.
Os argumentos contra esta abordagem são freqüentemente:
1) A fusão é difícil. Eu não gosto disso.
uma. Bem, na minha experiência com o Subversion e o CVS, a fusão é.
na verdade, bastante fácil. Eu posso ter alguns conflitos para resolver cada agora.
e novamente, mas geralmente são fáceis de resolver, especialmente se eu.
mantenha meu ramo atualizado com o tronco (o que pode ter tido alguns erros).
correções feitas ao longo do tempo)
2) Manter um registro de lotes de filiais é difícil.
uma. Na verdade não. Se eu usar uma boa convenção de nomeação, um punhado de.
Os ramos são fáceis de acompanhar. Não é como se eu estivesse indo.
tem centenas de ramos a se preocupar, na realidade.
3) Temos ramificações de lançamento para que você saiba exatamente o que está em um.
uma. Assim, essa abordagem - o que quer que esteja no tronco esteja dentro.
Produção. E, um ramo de lançamento por definição muda ao longo do tempo (até.
É marcado como final depois do qual ainda haverá um elemento de.
fundindo envolvido para sincronizá-lo com o ramo de desenvolvimento (tronco em.
Eu posso ver porque as pessoas favoreciam a estratégia do ramo de lançamento, porque.
isso parece muito mais simples, mas acho que os benefícios do recurso são baseados.
abordagem supera em muito os negativos. Eu espero que muitas pessoas.
discordo de mim, mas é um bom debate e gostaria de receber qualquer comentário.
Esta comunicação eletrônica é confidencial e para uso exclusivo.
do destinatário. Pode conter informações confidenciais e privadas.
As informações, anexos e opiniões contidas neste e-mail são.
somente de seu autor e não representam necessariamente as de.
London Scottish Bank PLC ou qualquer outro membro do London Scottish.
Se você não é o destinatário pretendido, você é proibido por qualquer.
divulgação, distribuição ou cópia adicional ou uso desta comunicação.
ou a informação contida nela ou a tomada de qualquer ação com base nela. Se vocês.
Recebeu esta comunicação por engano, informe as informações.
Gerenciador de segurança no ISM & # 64; London-Scottish & # 46; com o mais rápido possível e.
exclua a mensagem de todos os lugares no seu computador onde ela está armazenada.
Utilizamos software de varredura de vírus, mas não podemos garantir a segurança.
de comunicações electrónicas e você é aconselhável verificar qualquer.
anexos para vírus. Não nos responsabilizamos por qualquer perda.
resultantes de qualquer corrupção ou alteração de dados ou importação de.
qualquer vírus como resultado da recepção desta comunicação eletrônica.
As respostas a este E-mail podem ser monitoradas para operações ou negócios.
razões. London Scottish Bank PLC é regulamentado pelos Serviços Financeiros.
Este e-mail foi escaneado pelo sistema de segurança de email do MessageLabs.
Este e-mail foi escaneado pelo sistema de segurança de email do MessageLabs.
Esta comunicação eletrônica é confidencial e para uso exclusivo do destinatário. Pode conter informações confidenciais e privadas. As informações, anexos e opiniões contidas neste E-mail são apenas de autoria do autor e não representam necessariamente as do London Scottish Bank PLC ou de outros membros do London Scottish Group.
Se você não é o destinatário pretendido, é proibido qualquer divulgação, distribuição ou cópia adicional ou uso desta comunicação ou as informações nele ou tomar qualquer ação com base nela. Se você recebeu esta comunicação por engano, por favor notifique o Gerente de Segurança da Informação na ISM & # 64; London-Scottish & # 46; com o mais rápido possível e exclua a mensagem de todos os lugares do seu computador onde está armazenado.
Utilizamos o software de varredura de vírus, mas não podemos garantir a segurança das comunicações electrónicas e é aconselhável verificar quaisquer anexos de vírus. Não nos responsabilizamos por qualquer perda resultante de qualquer corrupção ou alteração de dados ou importação de qualquer vírus como resultado da recepção desta comunicação eletrônica.
As respostas a este E-mail podem ser monitoradas por razões operacionais ou comerciais. London Scottish Bank PLC é regulamentado pela Financial Services Authority.
Este e-mail foi escaneado pelo sistema de segurança de email do MessageLabs.
Recebido em Qua Nov 8 17:14:52 2006.
Esta mensagem: [Corpo da mensagem] Próxima mensagem: Nikki Locke: "Re: svn: eol-style issue" Mensagem anterior: cafahl_at_curdes: "número da versão na fonte ASM" Próximo no tópico: Les Mikesell: "RE: estratégia de ramificação - Feature vs Lançamento "Responder: Les Mikesell:" RE: Estratégia de ramificação - Feature vs Release "Responder: Ryan Schmidt:" Re: Branching strategy - Feature vs Release "Mensagens contemporâneas ordenadas: [Por data] [Por Thread] [Por Assunto] [Por Autor] [Por mensagens com anexos]
Este é um correio arquivado postado na lista de discussão dos Usuários do Subversion.

característica de estratégia de ramificação do Subversion versus lançamento
Obter através da App Store Leia esta publicação em nosso aplicativo!
Uma estratégia de gerenciamento de liberação melhor?
Eu trabalho para uma empresa que faz uma ferramenta baseada na web. Como parte do meu trabalho, foi dada a tarefa de engenharia de lançamento para este produto (algo que eu nunca tinha feito antes). Eu configurei o seguinte sistema usando SVN (Desculpe, não podemos usar outro repositório antes que alguém sugira mudar para GIT ou perforce ou uma das inúmeras outras opções!)
Tronco é o que está nos servidores de produção em todos os momentos Existem 2 filiais abertas a qualquer momento 1) Lançamento de manutenção. Isto é lançado todas as quartas-feiras 2) Ramo Sprint. Isto é liberado por semana (na quarta-feira com essa semana maint branch)
Antes da liberação, mesclari que as semanas se ramificam para o tronco.
Descobri que, ao executar o comando svn merge, ele geralmente cria uma tonelada de problemas quando é mesclado. Nós, assim, mudamos para uma reunião de mesclagem manual uma vez por semana, o que leva de 10 minutos a 1 hora, onde eu literalmente giro os dois diretórios no meu sistema e pergunto para cada desenvolvedor "foi essa sua mudança? Qual versão desse código devemos? guarda?"
Este sistema definitivamente NÃO é ideal.
Alguém pode sugerir algo melhor?
Em primeiro lugar, desiludido! Não invejo sua posição.
Eu trabalhei para um banco internacional fazendo redesign para o Federal Card Act. A mesma situação que você, provavelmente em uma escala muito maior. Nós tivemos 3 pessoas que não fizeram nada, mas liberaram o gerenciamento em um cronograma muito similar. O que fez isso capaz (em algumas semanas eu trabalhei com um par de cem arquivos por vez) era o fato de que os desenvolvedores se mesclavam ao tronco, então o tronco foi implantado na produção como uma cópia. não verificamos diretamente a produção. Então, do ponto de vista do lançamento, você pode estar ajudando os desenvolvedores do curral a verificar seu trabalho (qual é a diferença entre fazer uma "atualização" ou responder "esta é a versão correta?") Mas, então, você não está escolhendo cegamente As atualizações devem estar em andamento, o que parece ser um grande problema. Claro, os desenvolvedores podem se queixar um pouco, mas tendo estado nessa posição, na verdade não é muito ruim. E se você estiver disponível para responder a quaisquer perguntas que possam surgir, deve estar certo. Trabalhou para os 1.200 desenvolvedores ímpares que trabalhamos em 4 locais em todo o país.
A outra coisa que isso te compra é hora de testar. Se o código não é mesclado antes de entrar no ar, como ele pode ser testado no contexto do sistema maior? Espero que a resposta não seja que não seja testado!
Seu ramo tronco deve conter todo o código de desenvolvimento mais recente, que inclui recursos novos e não testados e qualquer código de outros ramos. É muito importante que todo o código seja mesclado nessa ramificação.
Quando estiver pronto (ou ache que está pronto) para testes, crie um ramo estável fora de seu tronco. Use este ramo para testar e corrigir apenas erros. Não adicione novos recursos ou melhorias ao seu aplicativo aqui, ou pode desestabilizar seu código existente. Não se esqueça de mesclar as alterações feitas neste ramo em seu ramo tronco.
Quando você estiver pronto para liberar (seu teste está completo), crie um branch de release fora de seu branch estável. Este é o ramo que você libera para a produção e mantém / suporta se erros / problemas são encontrados na produção. Tal como acontece com o ramo estável, não adicione nada novo a esta filial. Este ramo é geralmente marcado para identificá-lo na produção. Não se esqueça de mesclar as mudanças feitas neste ramo no ramo estável, de modo que outros ramos de liberação criados a partir do ramo estável recebam o benefício de todas as correções de erros feitas.
A hierarquia do ramo será semelhante à seguinte:
Usando esta hierarquia, sua equipe de desenvolvimento é livre para desenvolver em seu ramo tronco, enquanto os ramos estável e de lançamento permitem a manutenção das versões atual e anterior de sua aplicação.
A declaração "há 2 ramos abertos a qualquer momento" é problemático para mim. Pelo menos em meus ramos de prática são criados para estabilização antes de um lançamento ou para correção de bugs, e eles geralmente são de curta duração.
Minha pergunta é - para que você usa o porta-malas? Não deve ser o que está na produção, mas a produção deve estar executando uma versão etiquetada (portanto, lançada).
Seus problemas de fusão são auto-infligidos, tanto quanto eu posso ver.
A estratégia de ramificação ideal para este cenário é. Últimos desenvolvimentos no trunk e para cada release cortam um branch dele e o chamam de branch de release de manutenção. No entanto, no seu caso, a liberação de manutenção acontece no porta-malas. O desenvolvimento mais recente acontece no ramo.
Manter a estratégia de ramificação de lado. Aqui estão algumas sugestões para melhorar a situação atual.
Como você diz que as mudanças relacionadas à produção primeiro ocorrem no tronco, eu suponho que seria mínimo. Então, por que não mesclar cada mudança relacionada à produção nesses pares de outros ramos abertos com frequência. Eu diria uma vez por dia, também pode ser mais frequente ou menos frequente. você poderá julgar melhor. Isso também daria melhores cabeças aos desenvolvedores as mudanças que acontecem na produção, reduzindo o conflito. Além disso, se houver um conflito, isso seria tratado pelos próprios desenvolvedores no ramo.
Você pode pensar em criar algum tipo de estrutura.
Deve ser capaz de definir quais são os ramos que requerem os compromissos feitos no tronco.
Pode haver um script de gancho de confirmação de postagem que verificará se a confirmação está no tronco e faça uma fusão svn imediatamente com o ramo e veja se o seu é um conflito.
Se a mesclagem for bem sucedida, confirme as alterações. Além disso, envie as informações para você e para o desenvolvedor apropriado que as confirmou (depende de como você gostaria de lidar com isso).

característica de estratégia de ramificação do Subversion versus lançamento
Esta documentação foi escrita para descrever a série 1.7.x do Apacheв "ў Subversion®. Se você estiver executando uma versão diferente do Subversion, você é fortemente encorajado a visitar svnbook / e, em vez disso, consulte a versão desta documentação apropriada para sua versão do Subversion.
Padrões de ramificação comuns.
Há muitos usos diferentes para ramificação e svn mesclar, e esta seção descreve o mais comum.
O controle de versão é usado com mais freqüência para o desenvolvimento de software, então é uma rápida olhada em dois dos padrões de ramificação / fusão mais comuns usados ​​por equipes de programadores. Se você não estiver usando o Subversion para desenvolvimento de software, sinta-se à vontade para ignorar esta seção. Se você é um desenvolvedor de software que usa o controle de versão pela primeira vez, preste muita atenção, pois esses padrões são muitas vezes considerados melhores práticas por pessoas experientes. Esses processos não são específicos do Subversion; eles são aplicáveis ​​a qualquer sistema de controle de versão. Ainda assim, pode ser útil vê-los descritos em termos do Subversion.
Ramos de publicação.
A maioria dos programas tem um ciclo de vida típico: código, teste, lançamento, repetição. Existem dois problemas com esse processo. Primeiro, os desenvolvedores precisam continuar escrevendo novos recursos, enquanto as equipes de garantia de qualidade levam tempo para testar versões supostamente estáveis ​​do software. O novo trabalho não pode parar enquanto o software é testado. Em segundo lugar, o time quase sempre precisa suportar versões de software mais antigas e lançadas; Se um bug for descoberto no código mais recente, provavelmente também existe em versões lançadas, e os clientes vão querer obter essa correção de bugs sem ter que esperar por uma nova versão importante.
Aqui é onde o controle de versão pode ajudar. O procedimento típico parece assim:
Os desenvolvedores comprometem todo o trabalho novo no tronco. As mudanças do dia-a-dia estão comprometidas com / tronco: novos recursos, correções de bugs, e assim por diante.
O tronco é copiado para um ramo de "liberação". Quando a equipe pensa que o software está pronto para a liberação (por exemplo, uma versão 1.0), o tronco pode ser copiado para /branches/1.0.
As equipes continuam a trabalhar em paralelo. Uma equipe inicia testes rigorosos do ramo de lançamento, enquanto outra equipe continua um novo trabalho (digamos, para a versão 2.0) em / trunk. Se os erros forem descobertos em qualquer local, as correções serão carregadas para frente e para trás, conforme necessário. Em algum momento, no entanto, mesmo esse processo pára. O ramo está "congelado" para o teste final antes de um lançamento.
O ramo é marcado e liberado. Quando o teste estiver concluído, /branches/1.0 é copiado para /tags/1.0.0 como um instantâneo de referência. A etiqueta é empacotada e lançada para clientes.
O ramo é mantido ao longo do tempo. Enquanto o trabalho continua em / trunk para a versão 2.0, correções de bugs continuam sendo portadas de / trunk para /branches/1.0. Quando suficientes correções de bugs se acumulam, o gerenciamento pode decidir fazer uma versão 1.0.1: /branches/1.0 é copiado para /tags/1.0.1 e a etiqueta é empacotada e liberada.
Todo esse processo se repete à medida que o software amadurece: quando o trabalho 2.0 estiver completo, um novo ramo de liberação 2.0 é criado, testado, etiquetado e eventualmente lançado. Depois de alguns anos, o repositório termina com vários ramos de lançamento no modo "manutenção", e uma série de tags que representam as versões enviadas.
Ramos de recursos.
Um ramo de recursos é o tipo de ramo que tem sido o exemplo dominante neste capítulo (aquele em que você trabalhou enquanto a Sally continua trabalhando no tronco). É uma ramificação temporária criada para trabalhar em uma alteração complexa sem interferir na estabilidade de / trunk. Ao contrário dos ramos de lançamento (que podem precisar ser suportados para sempre), os ramos de recursos nascem, usados ​​por um tempo, fundidos de volta ao tronco e, em seguida, excluídos. Eles têm um período finito de utilidade.
Novamente, as políticas de projetos variam amplamente sobre exatamente quando é apropriado criar um ramo de recursos. Alguns projetos nunca usam ramos de recursos: os compromissos para / tronco são gratuitos para todos. A vantagem desse sistema é que é simples: "ninguém precisa aprender sobre ramificação ou fusão. A desvantagem é que o código do tronco é muitas vezes instável ou inutilizável. Outros projetos usam ramos para um extremo: nenhuma mudança já foi comprometida com o tronco diretamente. Mesmo as mudanças mais triviais são criadas em um ramo de curta duração, cuidadosamente revisadas e fundidas no tronco. Em seguida, o ramo é excluído. Este sistema garante um tronco excepcionalmente estável e utilizável em todos os momentos, mas ao custo de sobrecarga de processo tremenda.
A maioria dos projetos aborda a abordagem do meio-da-estrada. Eles geralmente insistem em que / compilar tronco e passar testes de regressão em todos os momentos. Um ramo de recursos é necessário apenas quando uma mudança requer um grande número de compromissos desestabilizadores. Uma boa regra geral é fazer esta pergunta: se o desenvolvedor trabalhou por dias isoladamente e depois comprometeu a grande mudança de uma só vez (de modo que o tronco nunca foi desestabilizado), seria uma grande mudança para revisão? Se a resposta a essa pergunta for sim, a mudança deve ser desenvolvida em um ramo de recurso. À medida que o desenvolvedor compromete mudanças incrementais no ramo, eles podem ser facilmente revisados ​​por colegas.
Finalmente, há a questão de como manter melhor um ramo de recursos em "sincronização" com o tronco à medida que o trabalho avança. Como mencionamos anteriormente, há um grande risco de trabalhar em uma filial por semanas ou meses; as mudanças do tronco podem continuar a derramar, até o ponto em que as duas linhas de desenvolvimento diferem tanto que pode se tornar um pesadelo tentando unir o ramo de volta ao tronco.
Esta situação é melhor evitada através da fusão regular das mudanças no tronco para o ramo. Elimine uma política: uma vez por semana, combine o valor da semana passada de alterações no tronco para o ramo.
Quando você finalmente estiver pronto para mesclar o ramo de características sincronizadas do tronco, comece fazendo uma fusão final das últimas mudanças no tronco para o ramo. Quando isso for feito, as versões mais recentes da ramificação e do tronco são absolutamente idênticas, exceto pelas alterações na ramificação. Você então mescla de volta com a opção --reintegrate:
Outra maneira de pensar sobre esse padrão é que sua sincronização semanal do tronco para o ramo é análoga à execução da atualização do svn em uma cópia de trabalho, enquanto a etapa de mesclagem final é análoga à execução do commit do svn a partir de uma cópia de trabalho. Afinal, o que mais é uma cópia de trabalho, mas um ramo privado muito superficial? É um ramo que é capaz de armazenar apenas uma mudança por vez.
Você está lendo o Controle de Versão com Subversion (para Subversion 1.7), de Ben Collins-Sussman, Brian W. Fitzpatrick e C. Michael Pilato.

O recurso abre caminho para a grandeza.
Ou tarefa que se ramifica para lá. Ou libere ramificações. Você escolhe.
Quase todos os sistemas de controle de versão atualmente suportam ramificações - linhas independentes de trabalho que derivam de uma base de código central. Dependendo do seu sistema de controle de versão, o ramo principal pode ser chamado de mestre, mainline, padrão ou tronco. Os desenvolvedores podem criar seus próprios ramos da linha principal do código e trabalhar de forma independente ao lado dele.
Por que se preocupar com a ramificação?
O Branching permite que equipes de desenvolvedores colaborem facilmente dentro de uma base de código central. Quando um desenvolvedor cria um ramo, o sistema de controle de versão cria uma cópia da base de código naquele momento. As mudanças na filial não afetam outros desenvolvedores no time. Isso é uma coisa boa, obviamente, porque os recursos em desenvolvimento podem criar instabilidade, o que seria altamente perturbador se todo o trabalho estava acontecendo na linha principal do código. Mas as filiais não precisam viver em confinamento solitário. Developers can easily pull down changes from other developers to collaborate on features and ensure their private branch doesn’t diverge too far from the master.
Branches aren't just good for feature work. Branches can insulate the team from important architectural changes like updating frameworks, common libraries, etc.
Three branching strategies for agile teams.
Branching models often differ between teams, and are the subject of much debate in the software community. One big theme is how much work should remain in a branch before getting merged back into master.
Release branching.
Release branching refers to the idea that a release is contained entirely within a branch. This means that late in the development cycle, the release manager will create a branch from the master (e. g., “1.1 development branch”). All changes for the 1.1 release need to be applied twice: once to the 1.1 branch and then to the master code line. Working with two branches is extra work for the team and it's easy to forget to merge to both branches. Release branches can be unwieldy and hard to manage as many people are working on the same branch. We’ve all felt the pain of having to merge many different changes on one single branch. If you must do a release branch, create the branch as close to the actual release as possible.
Release branching is an important part of supporting versioned software out in the market. A single product may have several release branches (e. g., 1.1, 1.2, 2.0) to support sustaining development. Keep in mind that changes in earlier versions (i. e., 1.1) may need to be merged to later release branches (i. e., 1.2, 2.0). Check out our webinar below to learn more about managing release branches with Git.
Feature branching.
Feature branches are often coupled with feature flags–"toggles" that enable or disable a feature within the product. That makes it easy to deploy code into master and control when the feature is activated, making it easy to initially deploy the code well before the feature is exposed to end-users.
Another benefit of feature flags is that the code can remain within the build but inactive while it's in development. If something goes awry when the feature is enabled, a system admin can revert the feature flag and get back to a known good state rather than have to deploy a new build.
Task Branching.
At Atlassian, we focus on a branch-per-task workflow. Every organization has a natural way to break down work in individual tasks inside of an issue tracker, like Jira Software. Issues then becomes the team's central point of contact for that piece of work. Task branching, also known as issue branching, directly connects those issues with the source code. Each issue is implemented on its own branch with the issue key included in the branch name. It’s easy to see which code implements which issue: just look for the issue key in the branch name. With that level of transparency, it's easier to apply specific changes to master or any longer running legacy release branch.
Since agile centers around user stories, task branches pair well with agile development. Each user story (or bug fix) lives within its own branch, making it easy to see which issues are in progress and which are ready for release. For a deep-deep dive into task branching (sometimes called issue branching or branch-per-issue), grab some popcorn and check out the webinar recording below–one of our most popular ever.
Now meet branching's evil twin: the merge.
We’ve all endured the pain of trying to integrate multiple branches into one sensible solution. Traditionally, centralized version control systems like Subversion have made merging a very painful operation. But newer version control systems like Git and Mercurial take a different approach to tracking versions of files that live on different branches.
Branches tend to be short-lived, making them easier to merge and more flexible across the code base. Between the ability to frequently and automatically merge branches as part of continuous integration (CI), and the fact that short-lived branches simply contain fewer changes, "merge hell" becomes is a thing of the past for teams using Git and Mercurial.
That's what makes task branching so awesome!
Validate, validate, validate.
A version control system can only go so far in affecting the outcome of a merge. Automated testing and continuous integration are critical as well. Most CI servers can automatically put new branches under test, drastically reducing the number of "surprises" upon the final merge upstream and helping to keep the main code line stable.
Agile has had a huge impact on me both professionally and personally as I've learned the best experiences are agile, both in code and in life. You'll often find me at the intersection of technology, photography, and motorcycling. Find me on Twitter! danradigan.
Sign up for more articles.
Obrigado por inscrever-se!
How to do scrum with Jira Software.
A step-by-step guide on how to drive a scrum project, prioritize and organize your backlog into sprints, run the Scrum ceremonies and more, all within Jira Software.
Git branching for agile teams.
Moving to Git opens up a whole new level of agility for software teams. Here's how to design branching schemes for shipping both SaaS and installed products.

FileCloud Blog.
Version control systems play a vital role in the success of a software development team. This blog aims to provide a simple branching and merging strategy to manage the code in a fast paced team development environment.
When do you need branching?
You may need to adopt branching in many different scenarios. Let us assume that on a day to day basis you use agile methodologies such as extreme programming or scrum and you have finally released a reasonably complex project with Version 1.0.0.0. Couple of days after the release, you get a request for a new feature that must go as Version 1.1.0.0. You envision it will take couple of weeks to get that feature coded, tested and released. Meanwhile, simple modifications and patches are requested on a day to day basis in the Version 1.0.0.0.
Essentially, with the changing business needs you are required to do a deployment every other day or so i. e. your deployment cycle is 2 days or less.
With a team of 10 developers it will be a nightmare in the absence of a proper branching strategy.
Trunk, branch, and tag are the 3 main divisions in subversion repository.
The code in trunk is always maintained as close to release state as possible. Any developer making changes to the trunk must be absolutely certain that his or her part can be coded, tested and is ready to deploy within 2 days (can vary depending on your length of deployment cycle). If it takes more than 2 days, they are not allowed to directly change the code in the trunk. They have to create a branch.
Each developer must create his or her own branch if their code will take more time to program than your normal deployment cycle. It is the responsibility of the developer to regularly (timeframe depends on your development environment) merge changes from trunk to his branch.
Create a feature branch if 2 or more developers are going to work on a new feature that will take considerable time to complete. It is the responsibility of the team lead to merge changes from trunk to this feature branch on a regular basis.
It is always beneficial to merge changes from trunk frequently. Because, after a couple of days conflict between trunk version and branch version can get out of hand and merging will practically be impossible.
When the developer branch or feature branch is ready for release, merge changes back from the branch to trunk.
Finally, remember that there is no ideal branching and merging strategy. It pretty much depends on your unique development environment. If you have any other strategy, I would like to hear about that.