Quando se trata de mesclar, cada versão de controle possui seu mecanismo para fazer isso. Conflitos são inevitáveis, mas a questão é - qual controle de revisão tem melhor IA para evitar conflitos.
É possível medir isso?
Mais especificamente, estamos pensando em mudar para o GIT, porque ele tem um hype e boato legais que lidam melhor com os conflitos ...
Qualquer comentário é apreciado ...
version-control
confiq
fonte
fonte
Respostas:
Eu não acho que essa seja a pergunta certa a ser feita.
O problema é que existem muitos casos de esquina, e algoritmos "inteligentes" para mesclagem podem enganar-se a pensar que eles fizeram a fusão corretamente quando, na verdade, eles destruíram completamente seu código. Se você tiver sorte, uma mesclagem tão ruim causa uma falha no tempo de compilação. Se você não tiver sorte, pode introduzir um bug sutil que leva séculos para ser rastreado.
O Git usa um algoritmo de mesclagem bastante simples, levanta as mãos e pede ajuda se não puder fazer a mesclagem. Na minha opinião, é exatamente isso que você deseja que seu sistema de controle de versão faça. A quantidade de sofrimento que você é poupado por isso vale bem o tempo que leva para corrigir manualmente os conflitos. (Além disso, se houver conflitos em uma mesclagem, o git lista os arquivos em conflito em sua mensagem de confirmação gerada automaticamente para você - isso é uma coisa muito útil para encontrar erros quando você estiver digitando seu histórico de códigos.)
fonte
Foi dito que o melhor algoritmo é a álgebra de patch de Darcs . Codeville também possui um algoritmo interessante em desenvolvimento.
No entanto, por todos os motivos práticos, qualquer ferramenta que use mesclagem de três vias o fará. Isso inclui git (com variantes), mercurial, bazar e muitas ferramentas externas (exceções notáveis: opendiff e caleidoscópio no Mac); portanto, com boa probabilidade, você já está usando as melhores opções; como observou o Peter, há casos em que nenhum algoritmo pode ajudá-lo.
fonte
Eu uso git e mercurial, mas sua pergunta lembra de mim a teoria dos patches dos dardos. Você terá que ler a lição de casa para este fim de semana.
PD: Não me pergunte a teoria dos patches, é muito complexo para mim :)
fonte
Chamava-se Controle de Revisão Humana. (Mecanismo de fusão humana)
Usamos o Seapine Surround e, na maioria das vezes, faz um bom trabalho de mesclagem, mas a única maneira de corrigir conflitos de mesclagem que o controle de origem não pode fazer é através da intervenção humana.
Então, meu conselho é:
Tente mesclar rapidamente. Um pesadelo foi ter um ramo que não voltou à linha principal por quase 2 anos. Quando foi mesclado, muitos conflitos precisavam ser resolvidos. Um desenvolvedor ganhou o apelido "mestre de mesclagem" depois de gastar muito tempo corrigindo problemas de mesclagem.
Tenha cuidado com o código gerado automaticamente pelos assistentes, etc. Às vezes, isso pode ser uma verdadeira dor de fusão, especialmente se dois ramos gerados automaticamente mudarem no mesmo arquivo.
Tente controlar o desenvolvimento. Se o desenvolvedor A estiver dividindo os arquivos de código X e Y, não faz muito sentido que o desenvolvedor B trabalhe com X e Y em uma ramificação diferente. Parte do gerenciamento de mesclagem é tentar controlar o que está sendo modificado para evitar o potencial de conflitos de mesclagem.
Isso não quer dizer que 2 desenvolvedores não possam trabalhar no mesmo arquivo em 2 ramos diferentes. Se um desenvolvedor adicionar o método A e outro método de adição B, a mesclagem deverá ocorrer sem problemas.
No final, sempre haverá alguns conflitos que precisam de intervenção humana. Ao mantê-las no mínimo, você obterá os melhores resultados de mesclagem.
fonte
O mecanismo de mesclagem perfeito entenderia a semântica do arquivo que está sendo mesclado: portanto, ele analisa e entende o código-fonte. Ainda estou para ver esse mecanismo de mesclagem / controle de versão ...
A maioria das ferramentas de mesclagem mescla arquivos como texto. Para nunca confiar neles cegamente, é sempre uma boa ideia revisar as alterações antes de enviá-las ao seu ramo.
Estamos usando o Perforce, que não se mescla automaticamente. Sempre que o arquivo de origem for alterado em relação à base comum, ele dirá que o arquivo de destino precisa ser resolvido mesmo se não houver conflito. Por isso, abro a ferramenta de mesclagem apenas para avançar rapidamente, pensando se eles se encaixam (e tenha uma ideia geral do que os outros colegas estão fazendo), na maioria das vezes eles se encaixam e aceitam o resultado.
Também assinei as notificações de alterações da linha principal para mesclar as alterações no meu ramo o mais cedo possível para evitar problemas mais tarde.
fonte
Erm ...
Ao usar o mercurial (e o git também, tenho certeza), você escolhe seu mecanismo de mesclagem, por padrão é o kdiff3, mas você pode usar o que quiser (além de comparar, p4merge etc.).
AFAIK, o mecanismo de mesclagem e o VCS geralmente são completamente separados , como seu compilador e editor de texto. Tomemos XML x código, por exemplo, você desejará que coisas diferentes mesclem essas, elas não funcionam da mesma maneira e, portanto, não podem ser mescladas da mesma maneira.
Se você estiver alternando o controle de versão porque precisa de uma ferramenta de mesclagem melhor, por motivos errados, deve alternar o controle de versão apenas quando o que você está usando agora não se encaixa bem no seu processo (ou outro permitem que você use um processo melhor).
fonte
O quão bem um VCS lida com conflitos dentro de um arquivo é um pouco superestimado. Por um lado, a melhor maneira de lidar com esses conflitos é não tê-los em primeiro lugar. Considerar bem o software e dividir as atribuições com premeditação reduzirá enormemente os conflitos dentro de um cluster de arquivos (quanto mais dentro de um arquivo). Faça um trabalho ruim, como jogar em muitas classes divinas, ou em um arquivo de configuração comum que todos precisam usar e que todos querem mexer, e você está pedindo conflitos no nível do arquivo.
Por outro lado, todos eles usam praticamente o mesmo algoritmo (ruim). Um exemplo: uma versão alfa do nosso projeto teve um pequeno vazamento de memória. Foi mais um gotejamento do que um vazamento, e o vazamento parou no final do tempo de inicialização. Digno de uma correção, não digno de um patch. Um de nossos clientes "corrigiu" o problema, colocando o grátis no lugar errado. O problema foi corrigido na próxima versão. Esse cliente mesclou a nova versão em vez de fazer uma substituição completa (WTF?). Não houve conflitos na fusão de três vias; as ligações para libertar estavam bem isoladas uma da outra. Portanto, agora o software está perdendo o foco devido a uma liberação dupla.
O que está faltando na discussão é o quão difícil / demorado / propenso a erros é mesclar seu trabalho de volta à linha principal do software.
Em svn, você
São muitas etapas não-atômicas, muitos lugares onde os erros podem surgir (os conflitos das árvores são desagradáveis) e leva muito tempo. Eu já vi vários projetos que desistiram de usar ramificações com subversão, graças ao processo de mesclagem ser tão demorado e propenso a erros. Já vi ainda mais projetos mudarem do subversion em grande parte por causa disso.
fonte
Há um pequeno conjunto de testes chamado mesclagem - que compara o sistema de controle de revisão com os cenários de mesclagem do mundo real. Para cada cenário, garante que um VCS possa fazer o seguinte corretamente:
Com base no número de testes aprovados na mesclagem, parece que existem duas camadas de desempenho:
Dependendo das linguagens de programação que você está tentando mesclar, os resultados exatos dos testes podem ser importantes. Consulte o site do projeto para uma tabela de comparação detalhada.
fonte
Eu usei o IBM / Rational ClearCase e sua fusão de várias filiais é simplesmente incrível. Executa anéis em torno da subversão. (Nenhuma experiência de Git ou mercurial.)
fonte