Apresentei o Git à minha equipe de desenvolvimento e todo mundo odeia, exceto eu. Eles querem substituí-lo pelo Team Foundation Server. Sinto que este é um grande passo para trás, embora não esteja muito familiarizado com o TFS. Alguém com experiência pode comparar o suporte a ramificação no TFS com a ramificação Git? Além disso, em geral, quais são os prós e os contras do TFS? Eu odeio isso depois de usar o Git por alguns anos?
263
Respostas:
Eu acho que a afirmação
faz qualquer outra resíduos discussão: quando você continuar a usar Git, eles vão culpar você se alguma coisa der errado.
Além disso, para mim, o Git tem duas vantagens sobre um VCS centralizado que eu mais aprecio (como descrito em parte por Rob Sobers ):
Mas como eu disse: acho que você está travando uma batalha perdida: quando todo mundo odeia o Git, não use o Git. Poderia ajudar você a saber mais por que eles odeiam o Git em vez de tentar convencê-los.
Se eles simplesmente não querem, porque é novo para eles e não estão dispostos a aprender algo novo: você tem certeza de que fará um desenvolvimento bem-sucedido com essa equipe?
Realmente todas as pessoas odeiam o Git ou são influenciadas por alguns líderes de opinião? Encontre os líderes e pergunte-lhes qual é o problema. Convença-os e você convencerá o resto da equipe.
Se você não conseguir convencer os líderes: esqueça de usar o Git, use o TFS. Facilitará sua vida.
fonte
A principal diferença entre os dois sistemas é que o TFS é um sistema de controle de versão centralizado e o Git é um sistema de controle de versão distribuído.
Com o TFS, os repositórios são armazenados em um servidor central e os desenvolvedores fazem check-out de uma cópia de trabalho, que é uma captura instantânea do código em um momento específico. Com o Git, os desenvolvedores clonam o repositório inteiro em suas máquinas, incluindo todo o histórico.
Um benefício de ter o repositório completo nas máquinas do desenvolvedor é a redundância, caso o servidor morra. Outra vantagem interessante é que você pode mover sua cópia de trabalho para frente e para trás entre as revisões sem nunca falar com o servidor, o que pode ser útil se o servidor estiver inoperante ou inacessível.
Para mim, o verdadeiro benefício é que você pode confirmar conjuntos de alterações no seu repositório local sem nunca falar com o servidor ou infligir alterações potencialmente instáveis à sua equipe (ou seja, interromper a compilação).
Por exemplo, se estou trabalhando em um grande recurso, pode demorar uma semana para codificá-lo e testá-lo completamente. Não quero fazer check-in de código instável no meio da semana e interromper a compilação, mas o que acontece se eu estiver chegando ao final da semana e acidentalmente copiar minha cópia de trabalho inteira? Se eu não cometer o tempo todo, corro o risco de perder meu trabalho. Isso não é controle de versão eficaz e o TFS é suscetível a isso.
Com o DVCS, posso confirmar constantemente sem me preocupar em interromper a compilação, porque estou comprometendo minhas alterações localmente . No TFS e em outros sistemas centralizados, não há conceito de check-in local.
Eu nem sequer me deparei com o quão melhor é a ramificação e a fusão no DVCS, mas você pode encontrar toneladas de explicações aqui no SO ou no Google. Por experiência, posso dizer que ramificar e mesclar no TFS não é bom.
Se o argumento para o TFS na sua organização é que ele funciona melhor no Windows do que no Git, sugiro o Mercurial, que funciona muito bem no Windows - há integração com o Windows Explorer (TortoiseHg) e o Visual Studio (VisualHg).
fonte
As pessoas precisam abaixar a arma, afastar-se da borda e pensar por um minuto. Acontece que existem vantagens objetivas, concretas e inegáveis para o DVCS que farão uma enorme diferença na produtividade de uma equipe.
Tudo se resume a ramificação e fusão.
Antes do DVCS, o princípio norteador era "Ore a Deus para que você não precise se ramificar e se fundir. E se o fizer, pelo menos implore a Ele para que seja muito, muito simples".
Agora, com o DVCS, a ramificação ( e a mesclagem ) é muito aprimorada, o princípio norteador é: "Faça isso rapidamente. Isso oferecerá muitos benefícios e não causará problemas".
E isso é um enorme aumento de produtividade para qualquer equipe.
O problema é que, para as pessoas entenderem o que acabei de dizer e convencidas de que é verdade, elas precisam primeiro investir em um pouco de uma curva de aprendizado. Eles não precisam aprender o Git ou qualquer outro DVCS ... eles precisam aprender como o Git se ramifica e se funde. Leia e releia alguns artigos e postagens do blog, devagar e trabalhando até que você o veja. Isso pode levar a maior parte de 2 ou 3 dias completos.
Mas, depois de ver isso, você nem considerará escolher um não DVCS. Porque realmente existem vantagens claras, objetivas e concretas no DVCS, e as maiores vitórias estão na área de ramificação e fusão.
fonte
Original : @Rob, o TFS tem algo chamado " Shelving " que aborda sua preocupação em comprometer o trabalho em andamento sem afetar a compilação oficial. Sei que você vê o controle central de versão como um obstáculo, mas com relação ao TFS, verificar seu código na prateleira pode ser visto como uma força b / c, em seguida, o servidor central tem uma cópia do seu trabalho em andamento no evento raro sua máquina local trava ou é perdida / roubada ou você precisa mudar de marcha rapidamente. O que quero dizer é que o TFS deve receber elogios apropriados nessa área. Além disso, a ramificação e a mesclagem no TFS2010 foram aprimoradas em relação às versões anteriores, e não está claro a qual versão você está se referindo ao dizer "... por experiência própria, que a ramificação e a mesclagem no TFS não são boas". Isenção de responsabilidade: eu sou um usuário moderado do TFS2010.
Editar 5 de dezembro de 2011 : Para o OP, uma coisa que me incomoda sobre o TFS é que ele insiste em definir todos os seus arquivos locais como "somente leitura" quando você não está trabalhando neles. Se você deseja fazer uma alteração, o fluxo é que você deve fazer o "check-out" do arquivo, o que apenas limpa o atributo somente leitura no arquivo para que o TFS saiba ficar de olho nele. Esse é um fluxo de trabalho inconveniente. A maneira que eu preferiria que funcionasse é que apenas detecta automaticamente se fiz uma alteração e não se preocupa / se incomoda com os atributos do arquivo. Dessa forma, eu posso modificar o arquivo no Visual Studio ou no Bloco de Notas ou com qualquer ferramenta que eu queira. O sistema de controle de versão deve ser o mais transparente possível a esse respeito. Há uma extensão do Windows Explorer ( TFS PowerTools), que permite trabalhar com seus arquivos no Windows Explorer, mas isso não simplifica muito o fluxo de trabalho.
fonte
Além de tudo o que foi dito (
), que está correto, o TFS não é apenas um VCS. Um recurso importante que o TFS fornece é a funcionalidade de rastreamento de erros nativamente integrada. Os conjuntos de alterações estão vinculados a problemas e podem ser rastreados. Várias políticas para check-ins são suportadas, bem como a integração com o domínio do Windows, que é o que as pessoas que executam o TFS possuem. A GUI firmemente integrada ao Visual Studio é outro ponto de venda, que agrada a
menos deum desenvolvedor de mouse e clique e seu gerente.Portanto, comparar o Git ao TFS não é uma pergunta apropriada a ser feita. A pergunta correta, embora impraticável, é comparar o Git com apenas a funcionalidade VCS do TFS. Com isso, o Git sopra o TFS para fora da água. No entanto, qualquer equipe séria precisa de outras ferramentas e é aí que o TFS fornece um destino de parada.
fonte
Se sua equipe usa o TFS e você deseja usar o Git, considere uma ponte "git to tfs". Essencialmente, você trabalha no dia-a-dia usando o Git no seu computador e, quando deseja enviar suas alterações, envia-as para o servidor TFS.
Existem alguns por aí (no github). Eu usei um no meu último lugar (junto com outro desenvolvedor) com algum sucesso. Vejo:
https://github.com/spraints/git-tfs
https://github.com/git-tfs/git-tfs
fonte
Depois de alguma investigação entre os prós e os contras, a empresa com a qual eu estava envolvido também decidiu optar pelo TFS. Não porque o GIT não é um bom sistema de controle de versão, mas o mais importante para a solução ALM totalmente integrada que o TFS oferece. Se apenas o recurso de controle de versão era importante, a escolha provavelmente poderia ter sido o GIT. A curva de aprendizado íngreme do GIT para desenvolvedores regulares pode, no entanto, não ser subestimada.
Veja uma explicação detalhada no meu blog TFS como uma verdadeira plataforma entre tecnologias .
fonte
A coisa toda distribuída do Git é realmente muito boa. fornece alguns recursos que os Shelvesets não possuem (no produto atual), como opções de reversão e confirmação local (como o recurso de histórico local do Eclipse ). Você pode aliviar isso usando ramificações de desenvolvedor, mas vamos ser honestos, muitos desenvolvedores não gostam de ramificar e mesclar um pouco. Pediram-me para ativar o recurso antigo de "checkout exclusivo" no TFS algumas vezes com muita frequência (e neguei-o sempre).
Eu acho que muitas grandes empresas estão com muito medo de permitir que um desenvolvedor traga toda a história para um espaço de trabalho local e leve-a com elas (para um novo empregador, por exemplo) ... Roubar um instantâneo é ruim, mas tirar toda uma história é ainda mais problemático. (Não que você não tenha conseguido obter um histórico completo do TFS ) ...
Mencionou-se que é uma ótima maneira de fazer backup, o que é ótimo para código-fonte aberto novamente, onde o mantenedor original pode parar para cuidar e remover sua versão, mas para um plano corporativo isso fica aquém para muitas empresas, pois não há uma atribuição clara de responsabilidade manter backups. E seria difícil descobrir qual versão usar se o 'projeto' principal desaparecer de alguma forma. O que tenderia a nomear um repositório como líder / central.
O que eu mais gosto no Git é a opção Push / Pull, na qual você pode facilmente contribuir com código para um projeto sem a necessidade de ter direitos de confirmação. Eu acho que você poderia usar usuários e prateleiras muito limitados no TFS para imitar isso, mas não é tão poderoso quanto a opção Git. A ramificação entre projetos de equipe também pode funcionar, mas, do ponto de vista administrativo, não é realmente viável para muitas organizações, pois a adição de projetos de equipe acrescenta muita sobrecarga administrativa.
Eu também gostaria de acrescentar às coisas mencionadas na área de controle que não é de origem. Recursos como rastreamento de itens de trabalho, relatórios e automação de compilação (incluindo gerenciamento de laboratório) se beneficiam muito de um repositório principal central. Isso se torna muito mais difícil quando você usa um modelo distribuído puro, a menos que você faça um dos nós à frente (e, portanto, volte para um modelo menos distribuído).
Com o TFS Basic fornecido com o TFS 11, pode não ser muito difícil esperar um TFS distribuído que permita sincronizar seu TFS básico local com um TFS central no TFS 12+. Vou colocar meu voto a favor no uservoice !
fonte
checkincomando (em vez de rcheckin). Mas eu prefiro rcheckin porque é mais a maneira git para fazer as coisas e é por isso que escolhemos para uso git;)Para mim, a principal diferença são todos os arquivos auxiliares que o TFS adicionará à sua solução (.vssscc) para 'dar suporte' ao TFS - tivemos problemas recentes com esses arquivos que foram mapeados para a ramificação errada, o que levou a uma depuração interessante ...
fonte
.gitpasta para rastrear todos os detalhes do repositório. O TFS modificará no mínimo o seu.sln(ou é o.csprojarquivos ?) Para colocar o local do repositório remoto.