Como posso gerenciar corretamente confirmações, impedir conflitos de recursos e gerenciar dependências com um VCS?

Tornou-se um fator irritante de trabalhar com equipes grandes: como você gerencia check-ins e evita conflitos de recursos e gerencia dependências com controle de origem corretamente?

Atualmente, no meu local de trabalho, usamos o TFS 2008 e estamos migrando para o TFS 2010 no início de dezembro. Em primeiro lugar, qualquer controle de origem é melhor que nenhum, mas que abordagem alguém achou útil para evitar vários checkins e reversões em todo o histórico de controle de origem? Um tronco volátil é o melhor caminho a percorrer ou se ramifica quando você implementa um novo recurso e, quando estiver feliz, volta a entrar no tronco?

Eu realmente gostaria de ouvir as experiências de outras pessoas e talvez algumas práticas recomendadas para gerenciar o controle de origem.

TFS? Corra para as colinas! Saia o mais rápido possível. Ele faz muitas coisas diferentes, mas nenhuma delas é tão boa quanto as melhores ferramentas disponíveis.

Mas seriamente:

Depois de ter um sistema de controle de versão decente (SVN, GIT, etc.), recomendo configurar regras para o gerenciamento de filiais, por exemplo, quando criar filiais, para o que, quando mesclar, quem e muito mais.

Até recentemente, usamos um único ramo para o novo desenvolvimento ('tronco'). Para uma versão, criaríamos uma ramificação fora do tronco. O controle de qualidade final seria feito nesse ramo e, uma vez concluído, lançaríamos (estamos em lançamentos mensais).

Mudamos para o conceito de 'sem lixo no porta-malas' para reduzir o risco do cronograma. Esse conceito basicamente contém uma regra pela qual você criaria ramificações para o trabalho de desenvolvimento separado do tronco. Por exemplo, você pode ter uma ramificação separada para um recurso, para uma pequena equipe de desenvolvimento ou similar. Usamos 'épicos' para descrever um pequeno recurso ou parte liberável de um recurso e criar uma ramificação para cada épico. Pelo menos uma vez por dia, todas as alterações do tronco são mescladas no ramo épico. A chave é um bom suporte de mesclagem pelo controle de versão ou uma ferramenta separada (por exemplo, mesclagem de três vias). O controle de qualidade da epopéia seria realizado no ramo da epopéia. Uma vez aprovada, a ramificação épica seria mesclada no tronco e um teste de integração seria executado. Ainda temos ramificações para lançamentos.

Com as ramificações épicas, reduzimos substancialmente o risco do cronograma, pois agora estamos em posição de liberar o tronco e incluir todos os épicos que foram mesclados com sucesso no tronco. Épicas que não estão completas perdem o ônibus e farão o próximo lançamento (mês que vem).

Obviamente, isso pode funcionar apenas em nosso ambiente. Muito provavelmente você terá fatores diferentes dos nossos que influenciarão quais são as melhores escolhas para o gerenciamento de filiais.

Por exemplo, se você tem uma equipe com muitas pessoas trabalhando remotamente e nem sempre está conectada ao servidor de controle de versão, convém usar um sistema de controle de versão que suporte um modelo distribuído. O GIT e alguns outros se enquadram nessa categoria. O TFS, tanto quanto sei, requer uma conexão com o servidor para tornar os arquivos graváveis ​​(corrigido na versão 2010?).

Espero ter conseguido mostrar que não existe "tamanho único". Comece com seus processos, em particular no gerenciamento de filiais, determine os requisitos e, finalmente, selecione a ferramenta que melhor corresponde às suas necessidades. Talvez seja TFS, talvez não.

Defendo um ramo por recurso, pois permite uma grande flexibilidade ao decidir quais recursos enviar e quais adiar.

O quão bem isso funciona na sua situação depende de quão bem o seu VCS lida com ramificações e, mais importante, com a fusão. DVCS como Git & Mercurial fazem deste um exercício relativamente trivial. SVN menos. Eu consegui evitar o TFS, apesar de ter lido muito sobre isso, principalmente, como cortesia. Se você está preso ao TFS, faça uma pequena versão piloto com base em um recurso por filial e veja como a fusão vai bem para você.

Em primeiro lugar, um aviso. É difícil dizer qual é a melhor maneira de gerenciar sua fonte, pois não temos conhecimento de como sua equipe ou equipes trabalham no dia a dia.

Geralmente, é melhor trabalhar no porta-malas. Para cada versão principal, ramifique-a - para que as correções de erros da versão estejam na ramificação que pode ser mesclada novamente no tronco. Todos os desenvolvedores trabalham no tronco e confirmam o código regularmente (mínimo uma vez por dia).

A mesclagem de novo código minimiza regularmente a dificuldade de mesclar grandes pedaços de código em uma fase de integração massiva. Ao espalhar a dor, você sentirá menos. Quanto mais os membros da sua equipe confirmam o código, menos eles precisam ser mesclados - porque eles sempre estarão na fonte mais recente.

Eu nunca usei o TFS 2008/2010, mas pelo que li em vários fóruns, há muita negatividade sobre o uso do TFS para controle de versão. Isso me fez ficar claro do TFS até agora.

Atualmente, estou usando o SVN e o Git, acho-os bons tanto para equipes pequenas quanto para homens solteiros, mas não recomendaria pessoalmente o SVN para uma equipe grande.

Estou de olho no PlasticSCM e tentarei fazer isso em um futuro próximo.

Peço desculpas por não responder sua pergunta específica, teria postado um comentário se meus privilégios me permitissem.

Eu acho que o git torna todos os outros softwares de controle de origem obsoletos. Ramificação e mesclagem são fáceis e, se houver problemas, elas serão contidas, mas muitos problemas serão evitados pela forma como incentiva confirmações, ramificações e mesclagens muito frequentes. Cada usuário recebe uma cópia completa do repositório (isso pode ser removido, mas eu trabalho com uma base de código bastante grande e não é um problema), então há um backup automático. As confirmações / push / pull são rápidas e uma das coisas mais importantes é que interrompe o acoplamento entre o nome do arquivo e o rastreamento. Os dados do arquivo, incluindo o nome e o caminho, são um blob de dados referenciado por um nó da árvore, independente dos caminhos. Isso não é apenas mais seguro, mas certos tipos de problemas "nunca faça isso" em algo como o SVN não são um problema. Ele pode ser usado como uma configuração de hub tradicional ou ponto a ponto, e esses usos podem ser combinados livremente na mesma configuração. É criptograficamente seguro contra inserções não documentadas. E é muito rápido.

Acho que o uso em casa o tempo todo, apenas para acompanhar documentos e sincronizá-los entre computadores, porque é mais fácil confirmar e enviar ao servidor de arquivos do que fazer backup no servidor ou salvá-lo lá.

A desvantagem é um pouco acentuada na curva de aprendizado, pois quebra todas as regras com as quais as pessoas estão acostumadas com o controle de origem, de maneiras sutis, mas é uma curva de aprendizado curta e íngreme.

Algumas das boas práticas que realmente seguimos e nos ajudaram bastante:

1) Verifique se você não possui uma cópia gravável do arquivo em seu local e sempre verifique a edição. (Se às vezes você precisar trabalhar localmente, tente mesclá-lo no controle de origem antes do EOD.)

2) Rotule seus arquivos periodicamente, após pequenos marcos significativos.

3) Dê bons comentários no check-out ou no check-in. Isso ajudará na revisão, às vezes você não precisará abrir e comparar as versões.

como você gerencia check-ins e evita conflitos de recursos e gerencia dependências com controle de origem corretamente?

É, do meu ponto de vista, a tarefa de dois fatores: você deve fazê-lo a partir de aspectos técnicos (bons e fáceis e à prova de balas | mesclagem | auditoria etc.) e gerenciamento (política bem estabelecida "o que" "quando" e "como"). Duas ou até três camadas de código de separação no ALM: algo como "estável" (passou no teste de unidade), "instável" (todos os recursos incluídos foram concluídos, mas o aplicativo como produto tem perguntas pós-integração / sim, pode acontecer /) e " trabalho em progresso". Dessa maneira, o gerente de projeto adequado pode diminuir a interferência do trabalho do desenvolvedor em comum.

O TFS (que eu não uso, uso e não uso) tem alguns problemas fundamentais no AFAIK, no aspecto do Gerenciamento de controle de origem. Eu apenas faço um link aqui para alguns dos textos de James McKay:

• O Team Foundation Server é o Lotus Notes das ferramentas de controle de versão
• Mesclagem sem base no servidor Team Foundation - por quê?

Um artigo muito bom e recente que compara e concisa de forma clara e concisa algumas maneiras diferentes de trabalhar com o controle de origem está aqui: Controle de origem feito corretamente .

Não acho que exista uma estratégia / prática recomendada para usar o controle de origem. As equipes maduras que trabalham juntas há muito tempo têm muito menos "dor" nessa área, mesmo que não sigam exatamente as "melhores práticas" populares.

Quanto a quais ferramentas ... Quase não importa. O que realmente importa é que todos da sua equipe estejam na mesma página em relação ao uso. Isso significa que todos precisam entender como a linha de código é gerenciada e o que eles devem fazer. De qualquer forma, na prática, você normalmente não tem escolha sobre qual ferramenta usar. Aproveite ao máximo o que estiver usando.