Por que o Mercurial é considerado mais fácil que o Git?

Ao analisar as comparações, parece-me que poderia haver um mapeamento 1: 1 entre seus conjuntos de recursos. No entanto, uma declaração frequentemente citada é que "Mercurial é mais fácil". Qual é a base desta declaração? (caso existam)

Caso em questão: digamos que você deseja alterar o nome de usuário em todas as confirmações anteriores. Eu precisei fazer isso várias vezes por vários motivos.

Versão Git

git filter-branch --commit-filter '
        if [ "$GIT_COMMITTER_NAME" = "<Old Name>" ];
        then
                GIT_COMMITTER_NAME="<New Name>";
                GIT_AUTHOR_NAME="<New Name>";
                GIT_COMMITTER_EMAIL="<New Email>";
                GIT_AUTHOR_EMAIL="<New Email>";
                git commit-tree "$@";
        else
                git commit-tree "$@";
        fi' HEAD

Versão mercurial:

arquivo autores.convert.list:

<oldname>=<newname>

Linha de comando:

hg convert --authors authors.convert.list SOURCE DEST

Agora, qual parece mais fácil de usar?

Nota: Passei 2 anos trabalhando exclusivamente com o Git, então esse não é um discurso do tipo "Eu odeio, não entendi em 2 segundos".

Para mim, é a usabilidade. O Git é muito orientado para o Linux, com uma maneira de fazer as coisas. Isso significa linha de comando, páginas de manual e descobrir por si mesmo. Ele tinha uma GUI muito ruim (nota: estou baseando isso no msysGit de cerca de um ano atrás), que parecia apenas me atrapalhar. Eu mal podia usá-lo

A linha de comando era pior. Sendo um programa orientado para Linux, no Windows era muito difícil de usar. Em vez de uma porta nativa, eles simplesmente empacotaram o git com o MinGW (Think cygwin), o que tornou o trabalho com ele muito mais difícil. O MinGW não é o prompt de comando do Windows e apenas age de maneira diferente. É uma loucura que essa seja a única maneira de trabalhar com o Git. Mesmo no Linux, parecia que a única maneira era trabalhar com linha de comando direta. Projetos como o RabbitVCS ajudaram alguns, mas não foram muito poderosos.

A abordagem orientada à linha de comando e o fato de ser um programa Linux significava que quase todos os guias de instruções, documentação de ajuda e questões de fórum / controle de qualidade dependiam da execução de comandos monstruosos, como acima. Os comandos básicos do SCM (commit, pull, push) não são tão complexos, mas mais e a complexidade cresce exponencialmente.

Eu também odeio o único lugar em que muitos usuários de git do OSS parecem ficar por aqui: Github. Quando você acessa uma página do github pela primeira vez, ela te mostra tudo o que você pode fazer. Para mim, uma página git de projetos parece caótica, assustadora e muito poderosa. Até a explicação do que é o projeto é empurrada para baixo. O Github realmente machuca as pessoas que ainda não têm um site completo configurado. Seu rastreador de problemas também é terrível e confuso. Sobrecarga de recursos.

Os usuários do Git também pareciam muito cultos. Os usuários do Git parecem sempre ser os que iniciam as "guerras sagradas" sobre as quais o DVCS é melhor, o que força os usuários do Mercurial a se defenderem. Sites como http://whygitisbetterthanx.com/ mostram arrogância e uma mentalidade quase "Use my software or die". Muitas vezes, fui a vários lugares de ajuda apenas para ser inflamado por não conhecer o X, usar o X antes, usar o Windows etc. É uma loucura.

Mercurial, por outro lado, parece ir em direção a uma abordagem mais gentil. A página inicial deles parece muito mais amigável para os novos usuários do que a do Git . Em uma simples pesquisa no Google, o quinto resultado é o TortoiseHg, uma interface gráfica muito boa para o Mercurial. Toda a sua abordagem parece ser a simplicidade primeiro, o poder depois.

Com o Mercurial, eu não tenho bobagens SSH (SSH é o inferno no Windows), não tenho comandos estupidamente complexos, não tenho um usuário de culto a seguir, não tenho loucura. Mercurial simplesmente funciona.

O TortoiseHg fornece uma interface realmente utilizável (embora ultimamente pareça estar crescendo) que fornece recursos realmente úteis. As opções são limitadas ao que você precisa, removendo a desordem e as opções raramente usadas. Ele também fornece muitos padrões decentes

Mercurial, sendo muito amigável com os novatos, era muito fácil de entender. Mesmo alguns dos tópicos mais complexos, como os diferentes modelos de ramificação e edição de histórico, foram muito fáceis de seguir. Peguei Mercurial rapidamente e sem dor.

O Mercurial também funciona da primeira vez com pouca configuração. Em QUALQUER SO, posso instalar o TortoiseHg e obter todos os recursos que eu quero (principalmente os comandos do menu de contexto) sem precisar procurar Guis diferentes. Também está faltando a configuração do SSH (metade dos guias por aí diz usar Putty, Plink e Pagent, enquanto a outra metade diz usar ssh-keygen). Para novos usuários, o TortoiseHg leva alguns minutos para ser configurado, enquanto o Git leva de 30 minutos a uma hora com muita pesquisa.

Por fim, você tem os repositórios on-line. O equivalente ao Githubs é o BitBucket, que possui alguns dos problemas descritos acima. No entanto, há também o Google Code. Quando vou a um projeto do Google Code , não recebo sobrecarga de recursos, recebo uma interface limpa e agradável. O Google Code é mais uma combinação de repo / site on-line, que realmente ajuda a projetos de OSS que não possuem uma configuração de site existente. Eu me sentiria muito confortável usando o Google Code como site dos meus projetos por algum tempo, criando um site apenas quando absolutamente necessário. Seu rastreador de problemas também é poderoso, encaixando-se perfeitamente entre o quase inútil Issue Tracker do Github e a monstruosidade do Bugzilla .

Mercurial simplesmente funciona, pela primeira vez, sempre. Git fica no meu caminho e só me irrita quanto mais eu o uso.

Git versus Mercurial

Acredita-se que o Mercurial seja mais simples e fácil de aprender do que o Git. Por sua vez, geralmente existe a percepção de que o Git é mais flexível e poderoso. Isso se deve, em parte, porque o Git tende a fornecer mais comandos de baixo nível, mas também em parte porque o Mercurial padrão tende a ocultar recursos avançados , deixando aos usuários editar o arquivo de configuração do mercurial para ativar os recursos avançados que eles gostam. Isso geralmente leva à percepção de que recursos avançados não estão disponíveis no Mercurial.

Conceitos Git

O Mercurial sempre se concentrou mais nos aspectos da interface, o que facilitou o aprendizado originalmente. Em comparação com o Git, é necessário um entendimento mais superficial para operar com o Mercurial de uma maneira útil. A longo prazo, esse encapsulamento deu ao Mercurial a falsa aparência de ser menos poderoso e cheio de recursos do que realmente é.

Contexto: uso diariamente o Mercurial (para o trabalho) e o Git (para projetos paralelos e de código aberto). Eu uso principalmente ferramentas baseadas em texto com ambos (não IDEs) e estou em um Mac.

Em geral, acho o Mercurial mais fácil de trabalhar. Algumas coisas que eu acho tornam o Mercurial mais fácil:

1. Falta do índice. O índice é uma ferramenta poderosa que habilita muitos dos recursos do Git, mas também é uma camada extra que adiciona um passo em muitas coisas que faço regularmente. O fluxo de trabalho do Mercurial é mais semelhante a algo como svn.
2. Números de revisão em vez de shas. Isso é uma coisa pequena que eu acho que facilita muito o trabalho com comandos diários no Mercurial. É muito mais fácil colocar alguns números de revisão em sua cabeça durante uma reescalonização, mesclagem, etc. enquanto escreve um comando, do que fazer o mesmo com shas encurtados.
3. Ramos. A abordagem do Git para as ramificações nomeando commits é poderosa e substancialmente diferente de outros sistemas de controle de versão. Isso facilita muito algumas coisas. Acho que a abordagem do Mercurial combina com o svn pensando um pouco melhor e facilita a compreensão visual do histórico do ramo. Isso pode ser apenas uma preferência.

Isso é muito subjetivo e depende de uma pessoa para outra, mas sim, eu diria que para alguém completamente novo no VCS ou para alguém vindo de um dos VCS da "velha escola", o Mercurial parecerá mais fácil.

Por exemplo, adicionando arquivos, a inexistência do índice em Hg, a facilidade de voltar a algumas revisões antigas e ramificar a partir daí (apenas atualizar e confirmar) como alguns dos exemplos mais "óbvios". Agora, a maioria dos recursos de um sistema pode ser emulada em outro e vice-versa, mas isso requer algum conhecimento no Git, enquanto no Mercurial os padrões (se você me permitir chamá-los assim) são bastante "amigáveis". Essas pequenas coisas - a troca aqui e ali, o comportamento não óbvio em um comando e assim por diante ... essas coisas se somam e, no final, um sistema parece mais fácil de usar que o outro.

Apenas para completar a resposta; Eu uso o git, mas ao recomendar um VC para alguém que é "novo para eles", eu quase sempre recomendo o Mercurial. Lembro que, quando ele chegou às minhas mãos, parecia muito intuitivo. É minha experiência que o Mercurial produz menos wtf / minuto que o Git.

Eu acho que é simples assim: o Mercurial tem uma sintaxe mais familiar (principalmente para usuários do SVN) e está bastante bem documentado. Depois de se acostumar com a sintaxe Git, você achará tão fácil de usar quanto qualquer outra coisa.

As percepções podem estar mudando ao longo do tempo. O Mercurial é muito bem projetado e o Git também. O Mercurial parece ser mais fácil de aprender (pelo menos foi para mim), e houve dificuldades que encontrei no Git, que não tenho paralelo no Mercurial. Tentei aprender Python e Ruby e fui mais longe, mais rápido com o Python. Isso não significa que o Python seja sempre e em toda parte melhor que o Ruby, ou mesmo que seja melhor para mim. É exatamente o que eu aprendi e fiquei com. Os programadores costumam fazer guerras sagradas por preferência pessoal. Outros seres humanos também fazem isso.

Sou um usuário mercurial que tenta manter uma mente aberta sobre o Git e admito livremente que ele não "se tornou minha nova coisa favorita" na mesma medida que o Mercurial. Eu acho que o Git é realmente muito bom.

Um exemplo contrário para a complexidade GIT / mercurial: O suporte agradável ao GIT está embutido no XCode, no Mac. Menos fácil de usar o XCode com o Mercurial do que o GIT.

Minha experiência com o GIT até agora foi que eu me confundo e me perco e preciso consultar mais a documentação ao usá-la. Acredito que muita documentação foi escrita, mas nada que me permitiu "grok". Em segundo lugar, eu posso modificar e estender o Mercurial facilmente no Python, e como sou adepto do Python e como qualquer pessoa realmente pode aprender o python rapidamente, isso me parece uma vantagem. Eu também conheço C e escrevo extensões Python em C, então suponho que algum dia, se eu precisar de uma, eu poderia escrever facilmente uma extensão Git em C.

Facilidade de uso não é algo fácil de quantificar. Está lá e não acho que seja inteiramente subjetivo, mas não temos boas técnicas de medição objetiva. Quais seriam as unidades de facilidade de uso? Milli-iPods?

Não sou tão partidário a ponto de ser 100% pró-mercurial e 100% anti-git. Agora estou mais confortável com o Mercurial, no Windows e no Linux, e quando começar a trabalhar mais em Mac, espero tentar manter o XCode + GIT.

Atualização 2013: Agora usei o Mercurial AND GIT por tempo suficiente para encontrar alguns recursos que eu gostaria que o Git tivesse, como esta pergunta sobre estratégias de mesclagem. Realmente Git é incrível, se difícil de aprender, e às vezes enlouquecedoramente complexo.

Há algumas coisas que a IMO provavelmente colocará novos usuários fora do Git:

1. A cultura Git é mais centrada na linha de comando. Embora ambas as ferramentas tendam a se concentrar muito na linha de comando (como eu já disse várias vezes, as instruções da linha de comando podem ser poderosas e mais fluentes, mas não são uma boa estratégia de marketing ), esse é muito mais o caso do Git. Enquanto o Mercurial possui uma ferramenta GUI padrão de fato no TortoiseHg, que é até a opção de download padrão para usuários do Windows na página inicial do Mercurial, o Git tem vários front-ends da GUI concorrentes (TortoiseGit, Git Extensions, gitk, etc.) que não são bem anunciados no site do Git e, de qualquer maneira, são completamente desagradáveis. (Texto em preto nos rótulos vermelhos? Vamos lá, TortoiseGit, você pode fazer melhor que isso!) Há também uma atitude muito mais difundida na comunidade Git de que as pessoas que usam ferramentas da GUI não são desenvolvedores de software adequados.

2. O Git possui vários padrões prontos para uso que fazem todo o sentido para usuários avançados, mas provavelmente serão surpreendentes, se não intimidadores, para novos usuários. Por exemplo, é muito mais agressivo a automatização de tarefas como a mesclagem (por exemplo, o git pull mescla e confirma automaticamente, sempre que possível). Há um caso de mesclagens totalmente automatizadas , mas a maioria dos usuários inexperientes tem medo de mesclar e precisa ter a oportunidade de ganhar confiança em suas ferramentas antes de liberar todo o seu poder no código-fonte.

3. Documentação e complexidade inerente:

   $ hg help log | wc -l
   64
   $ git help log | wc -l
   912
   

Uma coisa que consigo pensar é

git add .
git commit -am "message"

vs.

hg ci -Am "message"

git commit -anão adiciona arquivos recém-criados, hg ci -Ao que significa que algo que requer dois comandos com o git pode ser feito com um comando no Mercurial. Por outro lado, "menos digitação" não significa necessariamente "mais amigável".

Porque é.

Git expõe muito mais coragem do que mercurial. Você pode usar o mercurial em poucos minutos depois de pegá-lo, mas acho que o git ainda é muito difícil de lidar depois de alguns meses de luta com ele (eu fiz muito pouco nos últimos dois meses além de tentar aprender o git ) Eu estou usando ambos na linha de comando e principalmente no Linux, então isso não é apenas uma aversão à interface da linha de comando.

Um exemplo simples são os relativamente poucos sinalizadores e argumentos de linha de comando necessários para o mercurial em comparação ao git. A área de preparação e o comportamento do comando add no git também adicionam mais complexidade do que o necessário. O trio de redefinição, check-out e reversão e suas múltiplas permutações adicionam uma complexidade enorme, o que era bastante desnecessário quando você testemunha a natureza direta da reversão e atualização no mercurial.

Concordo com o comentário acima também sobre o Hginit , que definitivamente tornou muito mais fácil compreender o mercurial. Bem escrito e muito fácil de entender. Nenhuma documentação escrita para o git chega perto. Por um lado, acho que a maior parte do que é escrito por Scott Chacone (que escreveu sozinho a maioria da documentação / livros sobre git) é particularmente confusa.