# Git vs Mercurial
## Git

O Git é um sistema de controle de versão desenvolvido pelo criador do kernel do linux e recentemente vem sendo largamente utilizado pela comunidade de desenvolvedores startups, o Git oferece um controle de versão diferente, o Distributed Version Control, ou simplesmente, controle de versão distribuído, com esta forma de controle não existe um servidor central como no SVN por exemplo, que usa versão centralizada, a comunidade diz que o Git é o controle de versão mais rápido do mercado, dentre alguns que usam o Git podemos citar o Linux Kernel, Wine, Fedora, dentre outros, o Github se estabilizou como um grande controle de versões baseado em Git, provendo um belo front end para grandes projetos como Rails e Prototype, entretanto, o Git não é muito fácil de se aprender, sendo portanto, não muito recomendado para iniciantes no mundo de controle de versões.A instalação do git pode ser feita em várias plataformas: Linux, Mac, Windows.

## Mercurial

O Mercurial é outro controle de versão distribuído assim como o Git, ele foi desenvolvido para projetos de grande porte, muito além dos projetos simples de designers e desenvolvedores independentes, obviamente isso não significa que times pequenos não possam utilizá-lo, o Mercurial é extremamente rápido e os criadores focaram na performance como recurso mais importante. Além de ser muito rápido e escalável, o Mercurial é mais simples que o Git, não existem tantas funções para aprender e as funções são similares a outros CVS’s, além de ele vir equipado com uma interface web e ter uma excelente documentação. A instalação do mercurial pode ser feita em várias plataformas: Linux, Mac, Windows.

## Como instalar
#### Git no Ubuntu

Para instalação do pacote git no sistema operacional Ubuntu, existe um software empacotado para a sua instalação nos repositórios das distribuições Ubuntu, para acessá-lo deve-se utilizar o comando:

#### Mercurial no Ubuntu

Para a instalação do pacote Mercurial no Ubuntu também existe um software empacotado, para acessá-lo deve-se utilizar o comando:

## Mercurial
### Iniciando um Projeto

Neste exemplo prático, será ilustrado como proceder para iniciar um repositório na sua própria máquina ou clonar de um servidor. Primeiramente, para iniciar um repositório do zero, pode-se proceder com:
Após, para que se possa "commitar" as mudanças deve-se registrar o usuário editando o arquivo .hgrc. Abra com seu editor preferido este arquivo no seguinte local:
Assim, coloque as suas credenciais como abaixo e salve o arquivo:
Após, utilize o comando commit que as alterações serão anexadas.
Para copiar um repositório em um servidor, por exemplo no repositório da Sof2U, deve-se proceder com os seguintes comandos:

### Comparação de sintaxe entre comandos Git e Mercurial

| Git | Mercurial |
| git pull | hg pull -u |
| git fetch | hg pull |
| git reset --hard | hg update -C |
| git revert <commit> | hg backout <cset> |
| git add <new_file> | hg add <new_file> (Only equivalent when <new_file> is not tracked.) |
| git add <file> | Not necessary in Mercurial. |
| git reset | Not necessary in Mercurial. |
| git add -i | hg record |
| git commit -a | hg commit |
| git commit --amend | hg commit --amend |
| git blame | hg blame or hg annotate |
| git blame -C | (closest equivalent): hg grep --all |
| git bisect | hg bisect |
| git rebase --interactive | hg histedit <base cset> (Requires the HisteditExtension.) |
| git stash | hg shelve (Requires the ShelveExtension or the AtticExtension.) |
| git merge | hg merge |
| git cherry-pick <commit> | hg graft <cset> |
| git rebase <upstream> | hg rebase -d <cset> (Requires the RebaseExtension.) |
| git format-patch <commits> and git send-mail | hg email -r <csets> (Requires the PatchbombExtension.) |
| git am <mbox> | hg mimport -m <mbox> (Requires the MboxExtension and the MqExtension. Imports patches to mq.) |
| git checkout HEAD | hg update |
| git log -n | hg log --limit n |
| git push | hg push |

#### Branch no Mercurial

No Mercurial as branchs são permanentes. Isso significa que as branchs no Mercurial não podem ser removidas como no Git. Após ser criado merge entre branchs, a que recebeu o merge permanece enquanto a outra recebe apenas o status de desativada.
Para nomear/criar uma nova branch, separando-se da atual, assim como ocorre no git quando se utiliza do comando checkout para criar uma nova branch.
Após entrar localmente na pasta do projeto, pode-se criar uma nova branch.
Para transitar para outra branch, utiliza-se o comando:

#### Branch no Git

As branchs no Git, ao contrário do Mercurial, são temporárias e podem ser removidas a qualquer momento, seja localmente ou remotamente. O comando para a criação de uma Branch é o checkout.
O comando checkout permite a navegabilidade entre uma branch e outra.

#### Desempenho

As operações avaliadas são:
* Criação/clonagem de um repositório.
* Adição de arquivos
* Consolidação
* Visualização do estado, histórico e das diferenças
* Mesclagem (Merge)
* Comunicação entre repositórios (pull e push)
Para repositórios do estudo de caso muito pequenos. O Mercurial e o Git executaram seus comandos abaixo de 100ms. Nenhuma das duas ferramentas apresentou um tempo de resposta demorado o suficiente para que o desenvolvedor tenha motivo para se distrair com outras coisas.
Conforme esperado, o Git continua sendo extremamente rápido em repositórios pequenos. O destaque ficou com o Mercurial que foi muito rápido com o chg e até mais rápido que o Git em operações de clonagem, pull/fetch e push.
Obs:
* Abaixo de 100ms. Percebido como resposta instantânea.
* Abaixo de 1s. Nota-se o atraso, mas o usuário mantém o fluxo de pensamento.
* Até 10s. Limite que o usuário permanece focado na operação. Depois disso, os usuários tendem a executar outras atividades enquanto esperam a operação terminar.

#### Mercurial é mais fácil de aprender do que o Git?

Mercurial é visto como mais fácil de se utilizar e aprender do que Git. Por sua vez, há a existência da percepção que o GIT é uma ferramenta mais flexível e poderosa pois o Git tende a fornecer comandos de mais baixo nível em relação ao Mercurial, que tende a esconder a recursos avançados, deixando flexível aos usuários a edição do arquivo de configuração do mercurial para ativar os recursos avançados se fizerem necessário. Isto muitas vezes leva à percepção de que recursos avançados não estão disponíveis no Mercurial. Por outro lado , o Git tem melhorado tanto em documentação e facilidade de uso.

#### Flexibilidade

A interface de linha de comando do Git é projetada para ser extremamente flexível. Alguns comandos tem muitas opções que podem mudar seu comportamento. Isto minimiza unifica um único comando, mas exige que se saiba que o mesmo comando pode fazer ações diferentes. A abordagem do Mercurial é mais simples e faz com a que documentação deste seja mais elegante e concisa. É fácil encontrar o que você está procurando - usando hg help, então pode-se gastar menos tempo, olhar a documentação e voltar para a codificação.

#### Histórico de commits

A filosofia de Mercurial é que "a história é permanente e sagrada." O núcleo Mercurial inclui apenas um comando único que pode alterar a história : rollback hg . Este comando "desfaz" o último pull ou commit , mas nunca vai tocar em nada mais para trás .
O git, por outro lado, permite-lhe modificar a história do seu projeto. Comandos como git rebase permitem reescrever a história, possivelmente descartando dados ao longo do caminho.

#### Manipulação de arquivos grandes

Não é recomendado o uso de arquivos grandes em ambas ferramentas, pois, não é fácil de se diferenciar e comprimir estes arquivos em um repositório. Mesmo assim o mercurial tem um desempenho melhor. Funciona para repositórios de vários gigabytes de arquivos grandes. Git não manipula tais arquivos com a mesma eficiência.