Controle de versão semântico no Agile

Digamos que eu tenha 14 dias de iterações de sprint, onde eu tenho várias histórias para novos recursos, algumas melhorias e alguns bugs para corrigir. Também implanto essas alterações quando elas estão prontas, não estou esperando o final do sprint.

Meu problema é - como rastrear versões semânticas de produtos desenvolvidos e mantidos assim? Se houver uma liberação a cada 14 dias, será fácil, aumentarei o número da versão e observarei todas as alterações no log de alterações. Mas e se as mudanças forem implantadas continuamente? Deve haver versão aumentada sempre que algo é implantado? Ou devo esperar até o sprint terminar e, depois disso, fazer um "resumo" e aumentar o número da versão apenas uma vez por iteração, independentemente da implantação real? Quais são as práticas recomendadas para versões semânticas no Agile?

EDIT: Para explicar melhor minhas necessidades, quero um registro de alterações para as partes interessadas em primeiro lugar. Eu não acho que eles estarão interessados ​​em um novo registro no changelog após cada alteração implementada.

Para o gerenciamento de versão típico, você deseja que um número de compilação seja gerado pelo seu sistema de compilação, para que as DLLs sejam versionadas toda vez que forem implantadas. Isso garantirá que você possa verificar posteriormente qual versão está implantada em um determinado servidor.

Sua versão de 'marketing', que geralmente é colocada em notas de versão ou publicada em seu site, não deve ser atualizada a cada versão. Essas notas de versão devem ser acumuladas e agrupadas, provavelmente cronometradas no final do seu sprint.

Se o esquema clássico de versão semântica "MAJOR.MINOR.PATCH" fizer sentido, depende de quem você implanta e, principalmente, quando e com que freqüência você implanta no usuário final . O esquema é mais útil se você trabalha com a versão estável "4.5", onde começa como 4.5.0. As versões 4.5.1, 4.5.2 e assim por diante contêm apenas correções de bugs, enquanto você já trabalha internamente na versão 4.6.

Por exemplo, se você fornecer uma "ramificação estável" ao usuário final, forneça uma versão 4.5.0 para a implantação inicial e 4.5.1, 4.5.2 sempre que você lançar um patch. No seu desenvolvimento "ágil" interno e na implantação no meio do sprint, você já pode ter uma versão 4.6, basta chamá-la de "versão beta". Sempre que você implantá-lo no meio do sprint, adicione o número de compilação gerado automaticamente como "4.6.beta build 123". Quando o seu sprint terminar, atribua a ele "4.6.0" e troque o número da versão do próximo sprint internamente para "4.7". Começando com ".0" é apenas uma convenção, você também pode usar ".0" para marcar versões beta e começar com ".1" para seus usuários finais. IMHO a palavra "beta" é muito mais expressiva, dizendo a todos que o sprint "ainda não está concluído".

Se você liberar um log de alterações completo do usuário final com cada versão beta, é sua escolha, mas pelo menos no final do sprint, o log de alterações deve ser concluído e, sempre que você fornecer uma correção de bug ao usuário final, também deverá atualizar os documentos históricos.

Você encontrará a estratégia de liberar duas ramificações separadas, uma ramificação "estável" com números de versão semânticos e uma "ramificação de desenvolvimento" marcada com números de compilação ou algo semelhante, em muitos produtos de código aberto como Inkscape, Firefox ou 7-zip.

Se, no entanto, você não trabalha com ramificações estáveis ​​e de desenvolvimento separadas e libera uma nova versão para o usuário final diariamente, também deve incrementar um número de versão diariamente. Nesse caso, os números de versão "4.5.1", "4.5.2", ... provavelmente refletirão suas implantações individuais e não indicarão a diferença entre correções de erros e outras alterações. Isso pode ser bom, simplesmente não é mais o "versionamento semântico" clássico. Nesse cenário, você também pode implantar as versões 4.5, 4.6, 4.7, 4.8, que não dão diferença real.

Em relação à sua pergunta sobre entradas no seu log de alterações: IMHO quando algo estiver visível para o usuário final, vale a pena uma entrada no log de alterações, assim que você implantar a alteração. Por exemplo, se você usar alternâncias de recursos e fazer alterações em algum recurso incompleto que ainda não esteja ativado para o usuário, isso não pertence a um registro de alterações. Se você apenas refatorar, sem alteração visível no usuário, isso não pertence a um registro de alterações. Se você corrigir um bug que possa ter afetado alguns usuários, ele definitivamente pertence ao changelog - e deve ser mencionado lá ao mesmo tempo em que você implanta o bugfix. E não importa se você libera diariamente ou mensalmente ou anualmente.

Eu usaria números de compilação. Geralmente, um número de compilação corresponderia à versão mais alta do sistema de controle de versão. Se o número de compilação das segundas-feiras for 1745 e foram verificadas 5 alterações na terça-feira, o número de compilação das noites de terça-feira seria 1750.

Em seguida, faça um breve resumo do que mudou entre 1745 e 1750.

Então, toda vez que você atualizar o número da versão do seu sistema, poderá adicionar todos os resumos breves das compilações para obter as alterações do número da última versão para o novo.

Meu método preferido que uso há pelo menos alguns anos agora é aumentar o número após a conclusão de cada história. Isso significa que as versões lançadas no final do sprint não serão contínuas; por exemplo, após a versão 1.2.3, você pode encontrar a versão 1.5.2 e não a 1.4.0.

No registro de alterações, você pode listar as versões intermediárias com suas descrições correspondentes ou apenas agrupar todas as alterações na versão "liberada" e pular as versões intermediárias.

Inicialmente, eu tinha medo que os usuários achassem os "buracos" entre os números de versão problemáticos, mas uma vez que eles sabem disso, não é um problema na prática. A grande vantagem é que aumentar o número após cada história torna o processo menos propenso a erros - você não precisa verificar todo o trabalho a partir de duas semanas para decidir qual será o próximo número da versão - ao olhar para uma única história, é óbvio . Além disso, os "saltos" nos números de versão entre cada versão fornecem uma estimativa aproximada de quantas alterações foram feitas na versão. Em suma, achei que esse sistema funcionava bem (isso era com clientes internos da empresa, mas se você já trabalha em um ciclo de lançamento ágil, deve funcionar também para clientes externos).