uso adequado de Tags em SCM

Question

Os meus colegas e eu estamos tendo uma discussão sobre o valor e uso de etiquetas em sistemas de liberação / SCM. Nós estamos olhando para a comunidade StackOverflow para colocar em seus pensamentos para nos ajudar a resolver o problema.

Um reivindicações colaterais que tags são uma adição valiosa para gerenciamento de liberação. Um exemplo de seu uso: fazemos um lançamento Maven, o que torna um novo Tag (chamemos-lhe 1,0), que é instantâneo código usado para esta versão. Esta tag deve ser um ramo READONLY. Quando um erro precisa ser corrigido, podemos fazer uma cópia do Tag em um novo Branch (chamá-lo 1.1). correções de bugs ir lá. Essas correções podem estar de volta Incorporada Tronco de modo que o ramo principal dev recebe as correções de bugs. Finalmente, 1.1 é liberado e um Tag 1.1 é criado automaticamente. Este ciclo continua. A principal vantagem aqui do Tag é que, se você precisar re-lançamento da versão 1.0, por qualquer motivo, você pode apenas liberar o Tag 1.0 com a confiança de que isso nunca foi alterado por qualquer pessoa. Além disso, dizendo "Tag Release 1.0" é mais limpo do que dizer "revisão Release 1 do ramo 1.0 que é o 1.0 original, sem as correções".

As outras reivindicações colaterais que tags não estão fornecendo qualquer benefício valioso, especialmente em um sistema como o Subversion com revisões globais, que agem como um Tag no CVS. Além disso, o Subversion só dá um aviso quando se comprometer com um Tag; ele realmente não pará-lo. Seu método está desenvolvendo em Tronco e após a libertação você faria um ramo chamado 1.0. Você iria continuar correções de bugs no tronco e se for necessário para relançar essas correções para produção, você fundi-los em 1,0 Branch and re-release 1.0. Em algum momento, talvez depois de grandes correções ou recursos no tronco, você iria liberar e fazer ramo 1.1. Ciclo continua. Se você precisar liberar a versão original 1.0, você tem que verificar Filial 1,0 revisão 1.

É evidente que ambos os métodos de trabalho. Eu gostaria de ouvir os pensamentos da comunidade sobre qual método é o preferido e por quê.

Edit: Estou um pouco preocupado que o "melhor" forma depende do sistema SCM subjacente. Liquidá no Subversion para obter respostas ou, se possível, mantê-lo SCM agnóstico.

Answer 1

Do ponto agnóstico SCM de vista, a tag é muito diferente de uma revisão.

Ambos podem ser implementada da mesma forma, tanto representa uma "linha do tempo", mas seu objetivo é diferente:

• a tag representam um imutável estado onde todos os arquivos são referenciados por uma identificação única. É um nome representando muitas coisas mas principalmente um estado estável, ...)
• uma revisão representam uma transação de commit ( nem todos SCM tem aqueles , especialmente os antigos com uma 'abordagem arquivo por arquivo'). Todos os commits não representam um estado "estável" (como em "compilação" ou "executar" com sucesso). Eles são apenas um novo elemento da história global.

O problema com SVN é que a revisão, etiqueta e ramos são todas implementadas o mesmo.
Mas eu ainda prefiro a opção em que a tag é usada como um "read-only" ramo .

Answer 2

Em minhas marcas de opinião são úteis. Haverá momentos em algum momento na vida do projeto que você se deparar com um bug ou uma mudança e você quer saber se ele estava lá em uma versão anterior. Haverá razões para comparar o código de uma versão para outra para medir a eficiência tanto no desempenho e na verdade o desenvolvimento do código.

Claro, há uma chance de que você pode estragar tudo, mas sempre pode ser desfeita. Não há realmente nenhuma razão para não, e há várias razões pelas quais ele pode ser útil no futuro. Para mim é um acéfalo.

Eu concordo que você também deve estar usando galhos e fazendo o seu desenvolvimento lá, mas quando você realmente lançar algo, faça uma tag fora dele.

Answer 3

Sim, você quer marcas de uso.

Pense em um tag como apenas um rótulo ou um nome para uma revisão particular. É muito útil na minha experiência para marcar marcos importantes em um projeto, se é para versão de produção ou mesmo para lançamentos QA provisórias. Muitas vezes você vai querer voltar no tempo e ver o código fonte para uma versão particular.

Se você ramificar em cima da liberação, você sempre pode descobrir qual a revisão foi liberado para produção, mas este é um tipo de dor em comparação com apenas olhando para uma tag. Se você não usar ramos de libertação, em seguida, ele vai ser fácil para a faixa perder de qual revisão foi usada para criar uma compilação particular.

O problema com o SVN é que borra a distinção entre etiquetas e ramos. Qualquer um pode sempre se comprometer com uma tag, por isso não é garantido para ser fixo / imutável. Em outras VCS como PVCS, uma "tag" é imutável. Você pode adotar uma convenção equipe para evitar que se compromete a tag, ou talvez até mesmo o uso cometer ganchos para evitar que se compromete a tags.

Answer 4

Nós usamos tags (etiquetas) ao criar novas linhas de base. Fazemos isso uma vez por semana, mas algumas equipes fazê-lo mesmo várias vezes ao dia.

O ponto (para nós) é sempre ter certeza que a nova linha de base é estável:. Por isso não é apenas uma compilação, é uma compilação que passa todo o testsuite, várias horas de testes automatizados mais queridos exploratórios potencialmente manuais demasiado

Em seguida, a linha de base é utilizado como ponto de partida para todas as tarefas com início durante a próxima iteração: a cada nova tarefa é um novo ramo a partir da linha de base, que é conhecido por ser estável assim que o que está quebrado na tarefa deve ser fácil de traço dentro a própria tarefa.

Normalmente nós somente tags colocados (etiquetas) no ramo principal (ou tronco ou mestre dependendo do seu sabor SCM), que é o ponto de integração para todos os outros ramos.

Quando nós liberamos um produto oficial criamos um "ramo release para que" por isso só receberá correções enquanto novas estadias de desenvolvimento no "main". Em seguida, esses "ramos de manutenção" (esperamos que apenas um ou dois de cada vez) pode ser marcado também.

Answer 5

Eu gosto de pensar sobre tags como "apenas um nome fantasia para uma revisão". Eu sempre pensei sobre eles dessa maneira, e IIRC em mercurial eles são apenas isso. Em subversão no entanto, como você diz, eles realmente são (barato) cópias de trunk / * para tags / fantasia-name /

Honestamente, eu combinar as duas estratégias para melhores resultados: tag e ramo após a libertação. Seu tag é chamada 1.0.0, ramo 1.0-MAINT. Correções de bugs entrar em ramos, e libera bugfix são tags novamente (1.0.1 pode por um tag pretende apelido 1,0-MAINT em um determinado ponto.)

Não se esqueça, porém, que tags e ramos no Subversion são realmente a mesma coisa: cópias baratas. A única diferença entre eles é a semântica você / sua equipe atribui a eles, por isso praticamente resume-se a levar as pessoas a chegar a acordo sobre um método de particualr e vara para que (pode ser executada no servidor, por exemplo, não permitindo commits em tags / excepto para coordenadores de libertação etc.)

O problema que vejo, embora com a segunda abordagem é: como é que você vai fazer uma distinção fácil entre software no campo se você re-versão 1.0? Isso significa que você pode ter um 1.0 e outro 1.0 realmente referindo-se a uma base de código diferente ....

Answer 6

instantâneos imutáveis ??de código-fonte de um projeto (e executável) são de valor inestimável para fazer testes de qualquer espécie, seja estruturado testando ou uso do campo. Para o teste estruturado, você vai ser a criação de dados que possam ser referenciados meses ou anos no futuro. Sempre que você revisitar esses dados, a lei de Murphy diz que você precisa saber o código vem e, a menos que se deu ao trabalho de citar um instantâneo particular do código-fonte, será impossível dizer com confiança que o código fonte correspondeu que os dados de teste.

Eu não posso te dizer quantas vezes alguém de vir a mim e disse: "Este código microcontrolador não está funcionando, você pode ajudar?" e eu lhes pergunto, "Qual versão você está usando?" e eles dizem "não tenho certeza", porque eles não estão fazendo uma boa gestão de liberação (pelo menos colocar um adesivo no dispositivo, melhor colocar versionamento informação em EEPROM que pode ser consultado em tempo real). >: (

Answer 7

No SVN, a diferença técnica entre usar um tag e acompanhamento de uma revisão é nulo. Encontro-me minimizando o uso de tag com base em como a implementação do SVN é simplesmente uma cópia barata e tumultua o seu "espaço de estrutura".

A verdadeira diferença vem quando comunicação uma linha de base especial para uma grande equipe de desenvolvedores. rastreamento revisão traz uma camada extra de abstração que pode se tornar uma fonte de erros. E como estamos todos conscientes, quando você está lidando com 50+ desenvolvedores, qualquer fonte de erro se tornará uma área de confusão e perda de tempo. A tag detalhado pode eliminar essa confusão e eliminar qualquer dúvida quanto ao que o objetivo de uma linha de base é.

Answer 8

Eu combinar as duas abordagens. Sempre que você faz um lançamento, marcá-lo. Etiquetas nunca deve mudar, de modo que a presença de um tag "1.0.0" é um indicador de que você não deve estar tentando liberar qualquer outra coisa como 1.0.0.

Ao mesmo tempo, quando chegou a hora de fazer 1.0.0, eu colocá-lo em um ramo 1.0. Assim, o fluxo é: ramo do tronco a 1,0, tag este novo 1.0 como 1.0.0, e implantar. Em seguida, correções de bugs pode ser feito sobre o ramo 1.0 (para evitar ser misturado com qualquer 1.1-alvejado desenvolvimento que pode já estar no tronco de agora) e fundidos em tronco. Cada versão do 1.0 fixo é marcado como 1.0.x do ramo 1.0. Esta é basicamente a abordagem que usamos no trabalho com Perforce, e isso é muito semelhante, de fato para o Subversion. (Leitura através das respostas, eu acho que é virtualmente idêntica à recomendação de Vincent)

Quanto ao comentário sobre tags sendo redundante, porque você tem números de revisão --- que é em grande parte verdadeiro, exceto que as tags também especificar um escopo: ou seja, que os arquivos no repositório são cobertos pela marca. Você pode razoavelmente pedir a alguém para olhar para /svn/proj1/tag/1.0.0 e eles são imediatamente olhando para um espaço de trabalho coerente. Se você pedir-lhes para olhar para revisão X, eles têm que olhar primeiro para revisão X para ver que ele estava mudando (digamos) / svn / proj1 / trunk / Makefile e, portanto, deduzir que / svn / proj1 / trunk / @ X é o que eles devem estar olhando. O que acontece se a revisão X tocou arquivos em proj1 e proj2? Que é naturalmente mal, mas estritamente falando você deve estar dizendo / svn / proj1 / trunk / @ X. E onde está a lista de números de revisão são armazenados? Como sabemos que 1.0.0 é revisão X? Ele IMHO deve ser possível determinar que apenas a partir do repositório.

Em sistemas como Git, tags e ramos ainda são basicamente a mesma coisa (apenas referências ao banco de dados objeto), mas o convenção é que refs tag não mudam, e refs filiais fazer ( e de preferência com uma restrição específicas sobre como eles mudam). Perforce também tem "rótulos" que são maneiras de agrupar um conjunto de revisões de arquivos juntos independentemente de uma lista de alterações; que é essencialmente uma tag, mas mais confuso: Historicamente temos números changelists usados ??(equivalente a números de revisão do Subversion) qualificados com o nome do ramo que deve ser em identificar versões. Os dois são quase idênticos qualquer maneira, então aqui eu acho TMTOWTDI.