O código-fonte do interpretador Perl 5 está atualmente passando pelos estertores da conversão de Perforce para git. Talvez o git-p4rawimportador de Sam Vilain seja de seu interesse.
Em qualquer caso, uma das principais vitórias que você terá sobre cada VCS centralizado e a maioria dos distribuídos também é a velocidade bruta . Você não pode imaginar como é libertador ter todo o histórico do projeto à mão, a meras frações de frações de segundo de distância, até que você tenha experimentado isso. Mesmo a geração de um log de commit de todo o histórico do projeto que inclui uma diferença completa para cada commit pode ser medido em frações de segundo. Git é tão rápido que seu chapéu vai voar. Os VCSs que precisam percorrer a rede de ida e volta simplesmente não têm chance de competir, nem mesmo por um link Gigabit Ethernet.
Além disso, o git torna muito fácil ser cuidadosamente seletivo ao fazer commits, permitindo assim que mudanças em sua cópia de trabalho (ou mesmo dentro de um único arquivo) sejam distribuídas em vários commits - e em diferentes branches se você precisar. Isso permite que você faça menos anotações mentais enquanto trabalha - você não precisa planejar seu trabalho com tanto cuidado, decidindo antecipadamente que conjunto de alterações irá confirmar e adiando qualquer outra coisa. Você pode simplesmente fazer as alterações que desejar à medida que ocorrerem e ainda desemaranhá-las - quase sempre com bastante facilidade - quando for a hora de fazer o commit. O stash pode ser uma grande ajuda aqui.
Eu descobri que, juntos, esses fatos me fazem naturalmente fazer muito mais commits focados do que antes de usar o git. Isso, por sua vez, não apenas torna seu histórico geralmente mais útil, mas é particularmente benéfico para ferramentas que agregam valor, como git bisect.
Tenho certeza de que há mais coisas em que não consigo pensar agora. Um problema com a proposta de vender sua equipe no git é que muitos benefícios estão inter-relacionados e atuam entre si, como mencionei acima, de forma que é difícil simplesmente olhar para uma lista de recursos e benefícios do git e inferir como eles vão mudar seu fluxo de trabalho e quais mudanças serão melhorias genuínas. Você precisa levar isso em consideração e também apontar isso explicitamente.
Eu uso o Perforce no trabalho. Eu também uso o Git porque ainda gostaria de alguma forma de controle de versão quando estou trabalhando no código e não consigo me conectar ao servidor. Não, reconciliar o trabalho offline não é a mesma coisa. Aqui é onde descobri que o git é um grande benefício:
Bem, são meus 2 centavos. Em defesa do Perforce, devo dizer que suas regras de suporte ao cliente, assim como sua ferramenta Time Lapse View. Eu não sei como obter uma visão de lapso de tempo com o git. Mas para a conveniência e tempo economizado, eu iria com git qualquer dia.
fonte
Eu precisaria de muito para me convencer a mudar de força. Nas duas empresas que usei foi mais do que adequado. Ambas eram empresas com escritórios distintos, mas os escritórios foram configurados com muita infraestrutura, então não havia necessidade de ter recursos separados / desconectados.
De quantos desenvolvedores você está falando sobre a mudança?
A verdadeira questão é - o que há sobre forçosamente que não está atendendo às necessidades da sua organização que o git pode fornecer? E da mesma forma, quais fraquezas o git tem em comparação com forçosamente? Se você mesmo não consegue responder, perguntar aqui não ajudará. Você precisa encontrar um caso de negócios para sua empresa. (por exemplo, talvez seja com menor custo geral de propriedade (que inclui perda de produtividade para o estágio de aprendizado provisório, custos administrativos mais elevados (pelo menos inicialmente), etc.)
Eu acho que você terá uma venda difícil - forçosamente é uma boa opção para tentar substituir. É um acéfalo se você está tentando inicializar o PVC ou o ssafe.
fonte
Eu acho que em termos de manter as pessoas felizes durante / após a troca, uma das coisas a serem explicadas desde o início é como uma filial local pode ser privada no Git e quanta liberdade isso lhes dá para cometer erros. Faça com que todos eles clonem alguns branches privados do código atual e então vão à loucura, experimentando. Renomeie alguns arquivos, faça check-in, mescle coisas de outro branch, retroceda o histórico, rebase um conjunto de alterações sobre outro e assim por diante. Mostre como mesmo seus piores acidentes localmente não têm consequências para seus colegas. O que você quer é uma situação em que os desenvolvedores se sintam seguros, para que possam aprender mais rápido (já que o Git tem uma curva de aprendizado íngreme que é importante) e, eventualmente, para que eles sejam mais eficazes como desenvolvedores.
Quando você está tentando aprender uma ferramenta centralizada, obviamente você ficará preocupado em fazer alguma besteira que cause problemas para outros usuários do repositório. O medo do embaraço por si só é suficiente para desencorajar as pessoas de experimentar. Mesmo ter um repositório especial de "treinamento" não ajuda, porque inevitavelmente os desenvolvedores encontrarão uma situação no sistema de produção que eles nunca viram durante o treinamento e, portanto, eles voltam a se preocupar.
Mas a natureza distribuída do Git acaba com isso. Você pode tentar qualquer experiência em uma filial local e, se der terrivelmente errado, simplesmente jogue a filial fora e ninguém precisa saber. Já que você pode criar um branch local de qualquer coisa, você pode replicar um problema que está vendo com o repositório real, mas não corre o risco de "quebrar a compilação" ou de fazer papel de bobo. Você pode verificar absolutamente tudo, assim que fizer isso, sem tentar agrupar o trabalho em pequenos pacotes organizados. Portanto, não apenas as duas principais alterações de código nas quais você gastou quatro horas hoje, mas também aquela correção de compilação da qual você se lembrou no meio do caminho e o erro de ortografia na documentação que você identificou ao explicar algo a um colega e assim por diante. E se as principais mudanças forem abandonadas porque o projeto está mudando de direção,
fonte
O comando que me vendeu pessoalmente no git foi bisect . Não acho que esse recurso esteja disponível em qualquer outro sistema de controle de versão até agora.
Dito isso, se as pessoas estão acostumadas com um cliente GUI para controle de origem, elas não ficarão impressionadas com o git. No momento, o único cliente completo é a linha de comando.
fonte
git log --graph) porque os históricos de revisão do Git tendem a ser não lineares e difíceis de visualizar sem uma imagem. Eu uso GitX e SourceTree como GUIs, embora gitk (que vem com Git agora) seja passável em uma pitada.Quais recursos do Perforce as pessoas estão usando?
Eu pergunto porque se tudo que as pessoas estão fazendo é get e put a partir da linha de comando, o git cobre isso, e o mesmo acontece com todos os outros RTS.
fonte
Aparentemente, o GitHub agora oferece cursos de treinamento git para empresas . Quoth o post do blog deles sobre isso :
Ênfase minha.
fonte
Eu uso o Perforce há muito tempo e recentemente também comecei a usar o GIT. Aqui está minha opinião "objetiva":
Recursos do Perforce:
Recursos do GIT:
No geral para projetos OpenSource / Distributed eu sempre recomendaria o GIT, porque é mais parecido com uma aplicação P2P e todos podem participar do desenvolvimento. Por exemplo, eu lembro que quando eu estava fazendo desenvolvimento remoto com Perforce eu sincronizava Projetos de 4 GB em link de 1 Mbps uma vez por semana. Muito tempo foi simplesmente perdido por causa disso. Também precisamos configurar a VPN para fazer isso.
Se você tem uma empresa pequena e o servidor P4 está sempre ativo, eu diria que o Perforce também é uma opção muito boa.
fonte
Temos usado o Git por algum tempo, recentemente o disco rígido do nosso servidor Git travou e não foi possível reverter para o estado mais recente. Conseguimos voltar ao estado de poucos dias. Quando o servidor estava de volta. Todos na equipe puxaram / empurraram suas alterações e pronto, o servidor voltou ao estado atual.
fonte
A única diferença importante entre o Perforce e o git (e o mais comumente mencionado) é o respectivo manuseio de enormes arquivos binários.
Como, por exemplo, neste blog de um funcionário de uma empresa de desenvolvimento de videogame: http://corearchitecture.blogspot.com/2011/09/git-vs-perforce-from-game-development.html
No entanto, o importante é que, a diferença de velocidade entre git e perforce, quando você tem um enorme repositório de 6 GB, contendo tudo, desde a documentação até todos os binários já construídos (e finalmente, oh sim! O histórico de origem real), geralmente vem fato de que grandes empresas tendem a executar o Perforce e, portanto, configuram-no para descarregar todas as operações significativas para o enorme banco de servidores no porão.
Esta vantagem importante da parte do Perforce vem apenas de um fator que não tem nada a ver com o Perforce, o fato de que a empresa que o executa pode pagar o referido banco de servidores.
E, de qualquer forma, no final, Perforce e git são produtos diferentes. Git foi projetado para ser apenas um VCS, e faz isso muito melhor do que Perforce (no sentido de que tem mais recursos, que geralmente são mais fáceis de usar, em particular, nas palavras de outro, ramificar em Perforce é como executar o coração aberto cirurgia, só deve ser feita por especialistas: P) ( http://stevehanov.ca/blog/index.php?id=50 )
Quaisquer outros benefícios que as empresas que usam o Perforce ganham vêm simplesmente porque o Perforce não é apenas um VCS, é também um servidor de arquivos, além de ter uma série de outros recursos para testar o desempenho de compilações, etc.
Finalmente: sendo o Git de código aberto e muito mais flexível para inicializar, não seria tão difícil corrigir o git para descarregar operações importantes em um servidor central, executando montes de hardware caro.
fonte
Acho que a única coisa que sei que o GIT vence é a capacidade de "preservar terminações de linha" em todos os arquivos, ao passo que forçosamente parece insistir em traduzi-los para o formato Unix, Dos / Windows ou MacOS9 ("\ n", "\ r \ n "ou" \ r).
Isso é uma dor real se você estiver escrevendo scripts Unix em um ambiente Windows ou um ambiente de sistema operacional misto. Nem mesmo é possível definir a regra por extensão de arquivo. Por exemplo, ele converteria arquivos .sh, .bash, .unix para o formato Unix e converteria arquivos .ccp, .bat ou .com para o formato Dos / Windows.
No GIT (não tenho certeza se isso é padrão, uma opção ou a única opção), você pode configurá-lo para "preservar terminações de linha". Isso significa que você pode alterar manualmente as terminações de linha de um arquivo, e então o GIT deixará esse formato do jeito que está. Esta me parece a maneira ideal de fazer as coisas, e não entendo por que não é uma opção com o Perforce.
A única maneira de conseguir esse comportamento é marcar os arquivos como binários. A meu ver, seria um hack desagradável para contornar um recurso ausente. Além de ser entediante ter que fazer em todos os scripts, etc, provavelmente também quebraria a maioria dos diffs, etc.
A "solução" que decidimos no momento é executar um comando sed para remover todos os retornos de carro dos scripts sempre que eles forem implantados em seu ambiente Unix. Isso também não é o ideal, especialmente porque alguns deles são implantados dentro de arquivos WAR e a linha sed precisa ser executada novamente quando são descompactados.
Isso é apenas algo que eu acho que dá ao GIT uma grande vantagem, e que eu não acho que tenha sido mencionado acima.
EDITAR: Depois de usar o Perforce por mais um tempo, gostaria de adicionar mais alguns comentários:
A) Algo que eu realmente sinto falta no Perforce é um diff claro e de instância, incluindo arquivos alterados, removidos e adicionados. Isso está disponível no GIT com o
git diffcomando, mas no Perforce, os arquivos devem ser verificados antes de suas alterações serem gravadas, e embora você possa ter seus editores principais (como o Eclipse) configurados para verificar automaticamente os arquivos ao editá-los, você pode às vezes editar arquivos de outras maneiras (bloco de notas, comandos unix, etc). E novos arquivos não parecem ser adicionados automaticamente, mesmo usando Eclipse e p4eclipse, o que pode ser um tanto chato. Portanto, para encontrar todas as alterações, você deve executar uma "Diferença contra ..." em todo o espaço de trabalho, o que, em primeiro lugar, leva um tempo para ser executado e, em segundo lugar, inclui todo o tipo de coisas irrelevantes, a menos que você configure listas de exclusão muito complicadas, o que me leva ao próximo ponto.B) No GIT, acho o .gitignore muito simples e fácil de gerenciar, ler e entender. No entanto, as listas de ignorar / excluir do espaço de trabalho configuráveis no Perforce parecem pesadas e desnecessariamente complexas. Não consegui obter nenhuma exclusão com caracteres curinga funcionando. Eu gostaria de fazer algo como
Para excluir todas as pastas de destino em todos os projetos dentro do Server / mainline. No entanto, isso não parece funcionar como eu esperava, e acabei adicionando uma linha para cada projeto como:
E linhas semelhantes para pastas bin, arquivos .classpath e .projet e muito mais.
C) No Perforce, existem as changelists bastante úteis. No entanto, suponha que eu faça um grupo de alterações, verifico todas e coloco em uma changelist, para então trabalhar em outra coisa antes de enviar essa changelist. Se eu mais tarde fizer uma alteração em um dos arquivos incluídos na primeira changelist, esse arquivo ainda estará naquela changelist, e eu não posso enviar a changelist posteriormente presumindo que ela contém apenas as alterações que eu adicionei originalmente (embora serão os mesmos arquivos). No GIT, se você adicionar um arquivo e eles fizerem outras alterações nele, essas alterações não serão adicionadas (e ainda apareceriam em um
git diffe você não seria capaz de confirmar o arquivo sem primeiro adicionar as novas alterações também. Claro, isso não é útil da mesma forma que a lista de alterações pode ser, já que você só tem um conjunto de arquivos adicionados, mas no GIT você pode apenas enviar as alterações, já que isso não as empurra de fato. Você poderia trabalhar em outras alterações antes de enviá-los, mas não seria capaz de enviar qualquer outra coisa que você adicionasse posteriormente, sem enviar também as alterações anteriores.fonte
Não tenho experiência com Git, mas tenho com Mercurial que também é um VCS distribuído. Na verdade, depende do projeto, mas em nosso caso um VCS distribuído se adequou ao projeto, pois basicamente eliminou compilações quebradas frequentes.
Acho que depende muito do projeto, pois alguns são mais adequados para um VCS cliente-servidor e outros para um distribuído.
fonte
Aqui está o que eu não gosto no git:
Em primeiro lugar, acho que a ideia distribuída vai contra a realidade. Todos que realmente usam o git o fazem de forma centralizada, até mesmo Linus Torvalds. Se o kernel foi gerenciado de forma distribuída, isso significaria que eu não poderia realmente baixar as fontes "oficiais" do kernel - não haveria uma - eu teria que decidir se eu quero a versão de Linus ou a versão de Joe, ou a versão de Bill. Isso seria obviamente ridículo, e é por isso que existe uma definição oficial que Linus controla usando um fluxo de trabalho centralizado.
Se você aceitar que deseja uma definição centralizada de suas coisas, ficará claro que as funções de servidor e cliente são completamente diferentes, de modo que o dogma de que os softwares de cliente e servidor devem ser iguais torna-se puramente limitante. O dogma de que os dados do cliente e do servidor devem ser iguais torna-se patentemente ridículo, especialmente em uma base de código que tem quinze anos de história com a qual ninguém se importa, mas que todos teriam que clonar.
O que realmente queremos fazer com todo aquele material antigo é enfiá-lo em um armário e esquecer que está lá, como qualquer VCS normal faz. O fato de o git transportar tudo para a frente e para trás pela rede todos os dias é muito perigoso, porque te incomoda para podá-lo. Essa poda envolve muitas decisões tediosas e pode dar errado. Portanto, as pessoas provavelmente manterão toda uma série de repositórios de instantâneos de vários pontos da história, mas não era para isso que servia o controle de origem? Esse problema não existia até que alguém inventou o modelo distribuído.
O Git incentiva ativamente as pessoas a reescrever a história, e o que está acima é provavelmente um dos motivos para isso. Todo VCS normal torna a reescrita do histórico impossível para todos, exceto os administradores, e garante que os administradores não tenham razão para considerá-lo. Corrija-me se eu estiver errado, mas pelo que eu sei, git não oferece nenhuma maneira de conceder aos usuários normais acesso de gravação, mas bani-los de reescrever o histórico. Isso significa que qualquer desenvolvedor com ressentimento (ou que ainda está lutando com a curva de aprendizado) pode destruir toda a base de código. Como podemos apertar esse? Bem, ou você faz backups regulares de todo o histórico, ou seja, mantém o histórico ao quadrado, ou bane o acesso de gravação a todos, exceto a alguns pobres coitados que receberiam todos os diffs por e-mail e os mesclaria manualmente.
Vamos dar um exemplo de um grande projeto bem financiado e ver como o git está funcionando para eles: Android. Certa vez, decidi brincar com o próprio sistema Android. Eu descobri que deveria usar um monte de scripts chamados repo para chegar ao git. Alguns repo são executados no cliente e outros no servidor, mas ambos, por sua própria existência, estão ilustrando o fato de que o git está incompleto em ambas as capacidades. O que aconteceu é que não consegui obter as fontes por cerca de uma semana e desisti de vez. Eu teria que extrair uma quantidade verdadeiramente vasta de dados de vários repositórios diferentes, mas o servidor estava completamente sobrecarregado com pessoas como eu. O repo estava expirando e não foi possível retomar de onde havia expirado. Se o git é tão distribuível, você pensaria que eles ' d teria feito algum tipo de coisa ponto a ponto para aliviar a carga naquele servidor. Git é distribuível, mas não é um servidor. Git + repo é um servidor, mas repo não é distribuível porque é apenas uma coleção ad-hoc de hacks.
Uma ilustração semelhante da inadequação do git é o gitolite (e seu ancestral, que aparentemente não funcionou tão bem). Gitolite descreve seu trabalho como facilitar a implantação de um servidor git. Novamente, a própria existência dessa coisa prova que git não é um servidor, assim como não é um cliente. Além do mais, nunca será, porque se se transformasse em qualquer um deles estaria traindo seus princípios fundamentais.
Mesmo se você acreditasse na coisa distribuída, o git ainda seria uma bagunça. O que, por exemplo, é um galho? Eles dizem que você cria implicitamente um branch cada vez que clona um repositório, mas isso não pode ser a mesma coisa que um branch em um único repositório. Portanto, pelo menos duas coisas diferentes são chamadas de branches. Mas então, você também pode retroceder em um repositório e simplesmente começar a editar. É como o segundo tipo de branch ou algo diferente de novo? Talvez dependa do tipo de repo que você tem - ah, sim - aparentemente, o repo também não é um conceito muito claro. Existem normais e normais. Você não pode empurrar para um normal porque a parte vazia pode ficar fora de sincronia com sua árvore de origem. Mas você não pode cvsimportar para um só porque eles não pensaram nisso. Então você tem que cvsimport para um normal, clone isso para um arquivo vazio que os desenvolvedores acertaram e cvsexport para uma cópia de trabalho cvs que ainda precisa ser verificada no cvs. Quem pode ser incomodado? De onde vieram todas essas complicações? Da própria ideia distribuída. Abandonei o gitolite no final porque ele estava me impondo ainda mais dessas restrições.
Git diz que a ramificação deve ser leve, mas muitas empresas já têm um sério problema de ramificação desonesta, então eu pensei que a ramificação deveria ser uma decisão importante com policiamento estrito. É aqui que realmente brilha ...
Forçosamente, você raramente precisa de branches porque pode manipular changesets de uma maneira muito ágil. Por exemplo, o fluxo de trabalho normal é sincronizar com a última versão válida conhecida na linha principal e, em seguida, escrever seu recurso. Sempre que você tenta modificar um arquivo, o diff desse arquivo é adicionado ao seu "conjunto de alterações padrão". Quando você tenta fazer o check-in do changeset, ele automaticamente tenta mesclar as notícias da linha principal em seu changeset (efetivamente rebasando-o) e então se compromete. Esse fluxo de trabalho é aplicado sem que você precise entendê-lo. Dessa forma, a Mainline coleta um histórico de mudanças que você pode facilmente escolher mais tarde. Por exemplo, suponha que você queira reverter um antigo, digamos, aquele que antecede o penúltimo. Você sincroniza com o momento anterior à alteração ofensiva, marca os arquivos afetados como parte do conjunto de alterações, sincronizar com o momento seguinte e mesclar com "sempre meu". (Havia algo muito interessante lá: sincronizar não significa ter a mesma coisa - se um arquivo for editável (ou seja, em um changeset ativo), ele não será prejudicado pela sincronização, mas marcado como devido para resolução.) Agora você tem um changelist que desfaz o ofensivo. Junte-se às notícias subsequentes e você terá uma lista de mudanças que pode colocar no topo da linha principal para ter o efeito desejado. Em nenhum momento reescrevemos qualquer história. Junte-se às notícias subsequentes e você terá uma lista de mudanças que pode plopar no topo da linha principal para ter o efeito desejado. Em nenhum momento reescrevemos qualquer história. Junte-se às notícias subsequentes e você terá uma lista de mudanças que pode colocar no topo da linha principal para ter o efeito desejado. Em nenhum momento reescrevemos qualquer história.
Agora, supondo que no meio do processo, alguém venha até você e diga para você largar tudo e consertar algum bug. Basta dar um nome à sua lista de alterações padrão (na verdade, um número) e então "suspendê-la", consertar o bug na lista de alterações padrão agora vazia, confirmá-la e retomar a lista de alterações nomeada. É comum ter vários changelists suspensos ao mesmo tempo em que você tenta coisas diferentes. É fácil e privado. Você consegue o que realmente deseja de um regime de filial sem a tentação de procrastinar ou evitar a fusão com a linha principal.
Suponho que seria teoricamente possível fazer algo semelhante no git, mas o git torna praticamente tudo possível ao invés de afirmar um fluxo de trabalho que aprovamos. O modelo centralizado é um monte de simplificações válidas em relação ao modelo distribuído, o que é uma generalização inválida. Ele é tão generalizado que basicamente espera que você implemente o controle de origem, como o repo faz.
A outra coisa é a replicação. No git, tudo é possível, então você tem que descobrir por si mesmo. Forçosamente, você obtém um cache eficaz sem estado. A única configuração que ele precisa saber é onde está o mestre, e os clientes podem apontar para o mestre ou para o cache a seu critério. Isso é um trabalho de cinco minutos e não pode dar errado.
Você também tem gatilhos e formulários personalizáveis para avaliar revisões de código, referências de bugzilla etc. e, claro, tem branches para quando realmente precisar deles. Não é claro, mas está perto e é muito fácil de configurar e manter.
Em suma, acho que se você sabe que vai trabalhar de forma centralizada, o que todo mundo faz, é melhor usar uma ferramenta que foi projetada com isso em mente. Git é superestimado por causa da sagacidade temível de Linus junto com a tendência das pessoas de seguirem umas às outras como ovelhas, mas sua principal razão de ser não resiste ao bom senso e, ao segui-lo, git amarra suas próprias mãos com os dois grandes dogmas de que (a) o software e (b) os dados têm que ser os mesmos tanto no cliente quanto no servidor, e isso sempre tornará tudo complicado e coxo no trabalho centralizado.
fonte
Usar o GIT como substituto para o gerenciamento de linha de código ruim é comum. Muitas das desvantagens do Perforce são resultado de estratégias de ramificação ruins. O mesmo para qualquer outra ferramenta centralizada. Se você tiver que criar uma tonelada de branches, você está fazendo algo errado. Por que os desenvolvedores precisam criar tantos branches?
Além disso, por que trabalhar desconectado é tão importante? Só para alguém trabalhar em um trem? Esse é praticamente o único lugar hoje em dia em que você não consegue uma conexão sem fio. E até mesmo a maioria dos trens tem WiFi decente.
fonte