Sempre que queremos manter o histórico de alterações de arquivos, sejam eles código fonte de programas ou até mesmo documentos (aquelas várias versões do seu trabalho de conclusão de curso) entre outros arquivos, também é possível manter versões de arquivos binários, como fotos programas executáveis entre outros, porém para estes últimos alguns recursos não são possíveis, tais como ver as diferenças entre o arquivo na revisão 5 e 6.

Mas qual ferramenta usar?

Bem, existem várias e depende do molde que você quer trabalhar, mas eu posso recomendar hoje 3 ferramentas, e vou listar em ordem da mais fácil para a mais difícil de usar (na minha opinião), são elas: Bazaar, Git e Mercurial.
Presando pela facilidade de instalação e uso mas com todos os recursos dos demais e até mais algumas opções, minha opção foi o Bazaar.

Vou partir do princípio que você sabe instalar um software em seu sistema operacional, bem como utilizar um shell (“Promt de comando” para usuários windows). Todos os meus exemplos são feitos no Linux utilizando o gnome-terminal, sendo que para Windows alguns comandos do sistema operacional podem ser diferentes, mas os comandos do Bazaar são iguais.

Instalação

O Bazaar está disponível oficialmente para uma série de sistemas operacionais e também em forma de código fonte que “teoricamente” pode ser compilado em qualquer plataforma que rode Python.

• Linux: Se já não estiver instalado você pode facilmente encontrar em seu gerenciador de pacotes, geralmente o nome do pacote é “bzr” e não bazaar:
• Windows Siga as instruções de instalação (Em inglês) aqui ou clique aqui para baixar o diretamente o instalador da versão 1.9.
• Mac OS X: Siga as instruções aqui (Em inglês).
• Para outras plataformas e instalação via código fonte, veja mais informações aqui e aqui (Em inglês).

Se apresentando para o Bazaar

Antes de começar a controlar versão de coisas é interessante colocar sua identificação no Bazaar, para que ele possa “assinar” suas alterações nos arquivos, normalmente é utilizado o nome e email como identificação, portanto em um promt utilizando seus próprios dados digite:

  $ bzr whoami "Alexandre da Silva <simpsomboy@gmail.com>"

o Bazaar vai criar um arquivo de configuração (ou atualizar se ele já existir) incluindo sua identificação. para verificar qual a identificação você está utilizando atualmente ignore o segundo parâmetro e ele exibirá as configurações atuais:

  $ bzr whoami
  Alexandre da Silva <simpsomboy@gmail.com>

Controlando a versão de arquivos

Agora vem a parte interessante, vamos controlar a versão de alguns arquivos, para isso vamos criar uma pasta/diretório onde ficarão estes arquivos:

  $ mkdir arquivos
  $ cd arquivos
  $ mkdir adicionais
  $ touch teste1.txt teste2.txt teste3.txt adicionais/teste4.txt teste5.txt

(Usuários do windows não possuem o comando touch, e devem usar o Windows Explorer ou outra ferramenta para criar alguns arquivos texto vazios)

Até agora temos apenas uma pasta e um punhado de arquivos, vamos colocá-los agora no controle de versão:

  $ bzr init
  Standalone tree (format: pack-0.92)
  Location:
    branch root: .

Aparentemente nada foi feito, porém o Bazaar inicializou o diretório atual como um “branch” que nada mais é do que um local onde ficarão registradas todas as alterações realizadas nos arquivo pertencentes a ele. No Bazaar um branch é um diretório.

o próximo passo é adicionar os arquivos ao branch:

  $ bzr add
  added adicionais
  added teste1.txt
  added teste2.txt
  added teste3.txt
  added teste5.txt
  added adicionais/teste4.txt

Agora o Bazaar conhece os arquivos que ele deve manter o histórico, então vamos criar nossa primeira “revisão” dos arquivos existentes. Pense em uma revisão como uma foto do estado atual dos arquivos.

  $ bzr commit -m "Primeira versão"
  Committing to: arquivos/
  added adicionais
  added teste1.txt
  added teste2.txt
  added teste3.txt
  added teste5.txt
  added adicionais/teste4.txt
  Committed revision 1.

Como o Bazaar é um controle de versão distribuído não é necessário conectar a um servidor para enviar as alterações, todo o histórico de todos os arquivos ficam guardados dentro de apenas um sub-diretório especial chamado “.bzr” que fica no diretório raíz do branch.

Alterando seus arquivos

Vamos fazer algumas alterações e armazenar (commit) o que foi feito para o nosso branch.
Edite o arquivo teste1.txt em seu editor favorito, depois verifique o que foi feito:

  $ bzr diff
  === modified file 'teste1.txt'
  --- teste1.txt    2008-11-28 22:39:16 +0000
  +++ teste1.txt    2008-11-28 22:43:09 +0000
  @@ -0,0 +1,1 @@
  +teste teste teste

Armazene seu trabalho no branch:

  $ bzr commit -m "Adicionada primeira linha no arquivo teste1.txt"
  Committing to: arquivos/
  modified teste1.txt
  Committed revision 2.

Verificando o Log de alterações

Você pode ver todo o histórico do que foi modificado e quem modificou observando o log de alterações:

  $ bzr log
  ------------------------------------------------------------
  revno: 2
  committer: Alexandre da Silva <alexandre@exatisistemas.com.br>
  branch nick: arquivos
  timestamp: Fri 2008-11-28 20:44:12 -0200
  message:
    Adicionada primeira linha no arquivo teste1.txt
  ------------------------------------------------------------
  revno: 1
  committer: Alexandre da Silva <alexandre@exatisistemas.com.br>
  branch nick: arquivos
  timestamp: Fri 2008-11-28 20:39:16 -0200
  message:
    Primeira versão

Publicando seu trabalho em um servidor sftp

Existem várias maneiras de publicar um branch do Bazaar, mas uma das mais fáceis é utilizar um servidor sftp, se você tiver acesso a um você pode publicar seu branch da seguinte forma:

  $ bzr push sftp://seu.usuario@seu.servidor/~/arquivos
  Created new branch.

Criando sua própria cópia de um branch existente

Para trabalhar com os arquivos de outra pessoa você deve obter sua própria cópia (branch) para que possa trabalhar com os arquivos localmente em seu computador:

  $ bzr branch sftp://seu.usuario@seu.servidor/~/arquivos arquivos-copia1
  Branched 2 revision(s).

O Bazaar vai fazer o download de todas as revisões dos arquivos contidos no branch, além de uma cópia de trabalho contendo o estado atual dos arquivos.

Atualizando seu branch a partir de um branch remoto já modificado

Enquanto você modifica seus arquivos, os outros usuários também podem modificar os arquivos deles, podendo ser inclusive os mesmos arquivos, e neste último caso se for alterada a mesma parte do arquivo, há grande chace de você ter que resolver alguns conflitos, mas o processo é bem simples, mas em grande parte dos casos o Bazaar faz todo o trabalho para nós. Para atualizar nosso branch (cópia de trabalho) que já foi alterada, com um branch remoto que também já pode ter sido alterado, utilizamos o comando merge:

  $ bzr merge
  Merging from remembered parent location sftp://seu.usuario@seu.servidor/~/arquivos/
   M  teste2.txt
  All changes applied successfully.

Agora verificamos o que foi alterado:

  $ bzr diff
  === modified file 'teste2.txt'
  --- teste2.txt    2008-11-28 22:39:16 +0000
  +++ teste2.txt    2008-11-28 22:59:10 +0000
  @@ -0,0 +1,1 @@
  +editado editado editado

Estamos contentes com as alterações, vamos dar o nosso commit (armazenar nossas alterações) e em seguida publicar devolta para o branch remoto

  $ bzr commit -m "Merge a partir do branch principal"
  Committing to: arquivos-copia1/
  modified teste2.txt
  Committed revision 4.

  $ bzr push sftp://seu.usuario@seu.servidor/~/arquivos
  Pushed up to revision 4.

Como aprender mais

1. Eventualmente estarei postando mais informações relacionadas aqui no blog.
2. O Site oficial oferece uma ótima documentação, porém encontra-se em sua maioria em Inglês. http://doc.bazaar-vcs.org/latest/en/user-guide/index.html
3. O próprio Bazaar pode lhe dizer o que fazer em alguns casos, para tanto consulte a ajuda de linha de comando:

Informações sobre a linha de comando do Bazaar

  $ bzr help

Informações sobre vários comandos do Bazaar

  $ bzr help commands

Informações detalhadas sobre um comando específico

  $ bzr help [comando]

Este artigo foi fortemente inspirado e pode ser considerado uma tradução parcial de: http://doc.bazaar-vcs.org/latest/en/mini-tutorial/index.html

Por quê mudar para um controle descentralizado?

Bom já faz algum tempo que o controle de versão descentralizado está em alta em detrimento às opções que acredito serem mais utilizadas ainda hoje que são o SVN e o CVS. Quero dizer que o SVN e outras ferramentas centralizadas que utilizamos solucionaram o problema para nossa equipe durante muito tempo, No início quando programava em Delphi era utilizado um controle de de versão integrado a IDE chamado FreeVCS, que depois se tornou o JediVCS, resolvia o problema e o workflow utilizado era o de dar o CheckOut do arquivo a trabalhar (isso travava o arquivo no servidor e ninguém poderia alterá-lo) fazia-se as alterações necessárias em em seguida executava o CheckIn aplicando as alterações no repositório principal e liberando o arquivo para outros desenvolvedores, Um bom começo.

Um dia precisamos tratar branches e coisas do gênero, e surpresa o nosso amigo Jedi não suportava (acho que ainda não suporta), então a solução foi migrar. O escolhido para a migração foi o SVN, provavelmente os descentralizados já existiam, mas os na época qualquer pesquisa no Google sobre controle de versão devolvia toneladas de links para SVN. Tudo bem até ai, e como nenhum usuário de Windows gosta de usar o promt de comando acabei desenvolvendo um plugin para o Delphi que se comportava mais ou menos como o JediVCS mas com o SVN, daí em diante muitos projetos no SVN, em seguida migração de plataforma (Hoje utilizamos Linux embora os servidores já fossem Linux desde a migração para SVN). Mas às vezes era necessário levar parte da equipe para outro local (longe dos servidores internos), geralmente no cliente, onde eram feitas alterações no sistema. A solução não era muito prática, fazer o setup de um servidor SVN temporário para o desenvolvimento no local, depois pegar as revisões gerar um diff gigante das alterações e aplicar no repositório na empresa e resolver os conflitos com o que os desenvolvedores internos fizeram neste meio tempo. Quando um dia decidi que precisávamos de um controle de versão onde pudéssemos realizar algum trabalho desconectados do servidor interno e depois fosse menos trabalhoso juntar tudo novamente, além de, manter o histórico de cada um dos commits realizados.
Foi então que comecei a minha jornada em busca de um controle de versão distribuído* é claro que fosse OpenSource, a lista é grande, onde podemos citar alguns como Codeville, Darcs, Monotone, Mercurial, Git e Bazaar além de mais alguns que não cheguei nem a pesquisar. Desta lista poucos minutos de pesquisa me levaram a considerar apenas o Bazaar o Git e o Mercurial, e fazendo alguns testes percebi que todos poderiam satisfazer minhas necessidades usando Linux. Então vamos às necessidades:

1. Ser multiplataforma, afinal ainda tenho ainda hoje código fonte para manter em Delphi .
2. Possuir um modo de converter meus repositórios Subversion.
3. Ter uma curva de aprendizado pequena em relação ao SVN.
4. Tivesse como integrar com alguma ferramenta estilo Trac ou Redmine.

Primeira Tentativa: Mercurial

No primeiro quesito, à primeira vista ele se encaixa pois grande parte do seu código é escrito em Python, tem um instalador para Windows (que não me parece ser oficial). Mas esperem, eu sou fissurado por usar a Ultima versão da ferramenta que o Desenvolvedor disse que está estável, logo, não me interessa muito usar o instalador da versão Windows, que na época dos meus testes instalava algo em torno de 0.9 e a versão oficial já era a 1.0 (Março de 2008). Bom escrito em Python pensei eu, vamos ao easy_install……

c:\easy_install mercurial...... bam!

Erro, claro, não havia um compilador C. vamos lá instalei toda a MingW, MSyS etc, easy_install denovo, compilou, instalou beleza!. Não, o comando hg não funciona, bom vamos la, eu crio um hg.bat que chama o script do mercurial, jogo na pasta Scripts e tudo certo…. Também não, mais algumas tentativas depois consegui rodar o hg e ter um resultado. Bom, pra mim morreu aqui, não quero uma coisa que cada vez que tenho que instalar tenha que… Instalar um compilador C que os meus desenvolvedores Windows nao vão ter na máquina e fazer mais um monte de gambiarras pra ter versão “featured” do sistema. Enfim o Mercurial possui uma ferramenta de conversão de repositórios SVN e outros e tem integração com algumas ferramentas, inclusive o Netbeans, que por sinal, Surpresa!, também não funciona no Windows mesmo tenho o Mercurial funcionando no promt instalado via easy_install, acho que só funciona se for via installer mesmo. A curva de aprendizado dele é bem grande se formos levar em conta que sempre temos usuários bitolados, ei, eu disse bitolados?, eu quis dizer “acostumados” com o SVN e seu set de comandos, mal e porcamente.

Já é um caos fazer as pessoas entenderem o conceito de controle distribuído.

Segunda Tentativa: Bazaar

Bom eu já estava desanimado mas tinha que continuar, Uma olhada no site, cheio de tutoriais e extensiva documentação, Boa! documentação parece pelo menos ser bem melhor que a do Mercurial, embora eu tenha encontrado muitos posts em blogs dizendo o contrário, então só posso supor que, se a documentação do Mercurial é boa, ela está bem escondida em algum lugar do Wiki deles, bom blames à parte, Já vi um instalador para Windows e… hum, vamos tentar do velho e bom modo…

c:\easy_install bazaar ...

E instalou sem nenhum erro… bom eu já tinha um compilador C instalado, seria por causa disso? Vamos desinstalar tudo e ver o que acontece. Após remover todas as parafernalhas do MingW e Cia Ltda e remover o egg** do Bazaar e tentar novamente… vamos lá…

c:\easy_install bazaar

E funcionou novamente!, bom o Bazar é completamente escrito em Python, o que explica a tamanha portabilidade. o comando bzr já saiu funcionando, e, por curiosidade vou até a pasta Scripts, e… lá está um arquivo bzr.bat mais ou menos como o meu workarround, porém, out-of-the-box. Tudo funcionando agora vamos ver uma ferramenta de conversão, na época utilizei o svn2bzr, que funcionou perfeitamente, mas não importou as tags e relações dos branches, mas a história Linear do Subversion veio funcionando 100%. Hoje tem o bzr-svn que é um plugin para trabalhar diretamente com repositórios svn utilizando o bzr, e esta sim importa as tags referências de branches, merges etc. Ok curva de Aprendizado… uma estudada na documentação e, show de bola, não só tem praticamente todos os comanos similares aos do SVN, como também permite trabalhar com vários Workflows, inclusive o modelo Centralizado igual ao SVN. Então uma pequena busca por integração com os issue trackers, e, existiam plugins para bugzilla, Trac, Redmine e outros. eu na época estava utilizando o Trac e estava pensando em migrar para o Redmine, boa oportunidade para dar uma testada nele… Instalei testei e funcionou 100%, inclusive com aqueles comandos de commit, do tipo: bzr commit -m “This commit fixes #772″ para fechar o ticket numero 772. Perfeito.

Terceira Tentativa: Git

Já mais contente mas minha jornada ainda não estava finalizada, uma pequena pesquisada e achei um instalador do Git para windows, que não era exatamente a última versão, mas vamos dar um desconto, o Git é escrito em uma carrada de linguagens, uma parte em C outra em Perl outra em Shell Script e por ai vai, fazer isso integrar, e pior, Funcionar no Windows não deve ser das mais fáceis tarefas. Bem, feita a instalação, ele instalou um shell bem similar ao do Cygwin que praticamente dá a leve sençassão de estar em um terminal Linux,  e mais algumas ferramentas, ele utiliza o MingW, MSyS e outras bibliotecas para fazer a mágica de funcionar no Windows, Instalado fazer alguns testes, e gostei, segundo o próprio instalador e documentação afirma, alguns comandos não estão disponíveis pois falta ambiente***, mas para o uso diário geral show de bola. A curva de aprendizado….. hummm um pouco pior que a do Mercurial, porque por exemplo o comando checkout parece não ter nada haver com o que o SVN faz, embora para mim faça sentido, em fim, quando eu falei que era possível trocar de branch dentro da mesma cópia de trabalho com apenas um comando, ninguém entendeu nada, afinal totalmente fora deste planeta SVN. Continuando a conversão dos repositórios SVN também funcionou lindamente (bastante similar ao que hoje é o bzr-svn do Bazaar), e Integrou bonitinho com o Redmine, com uns pequenos probleminhas que não me recordo, mas, bastante usável.

Bom vejamos minha tabela de pontuação:

+----------+----------+-----------+----------+------------+
|          |Multiplat |SVN/Import | CurvaApr | Integracao |
+----------+----------+-----------+----------+------------+
|Mercurial |     5    |    ??     |     7    |    ??      |
+----------+----------+-----------+----------+------------+
|Bazaar    |    10    |     9     |    10    |     10     |
+----------+----------+-----------+----------+------------+
|Git       |     9    |    10     |    5     |     9      |
+----------+----------+-----------+----------+------------+

Bom tinhamos um vencedor, agora vamos fazer algumas pesquisas e comparativos para ver o que o Povo acha… e, Blames**** está cheio!
bom na opinião geral e também por mim constatada, o Git é o Mais Rápido para a Maioria das operações, Seguido do Mercurial e por Último o Bazaar, mas a maioria desses artigos falam em 100000 arquivos de 10000 linhas cada um, e fazem um monte de testes com 10000 revisões etc… claro algo escrito basicamente em C seria obviamente mais rápido que algo escrito parcialmente em C e Python do que algo Totalmente em Python, mas nos meus testes de uso geral, a diferença de performance é praticamente irrisória, mesmo trabalhando com árvores grandes.
Agora vamos ver quem utiliza cada uma destas ferramentas. Bem o Git foi contruído pelo Linus para manter o Kernel do Linux, e fora o Kernel temos outros projetos grandes utilizando. Já o Mercurial tem o pessoal da OpenJDK do Netbeans entre outros projetos Java***** . O Bazaar quem principalmente usa é a Canonical para manter grande parte do Ubuntu, li em algum lugar (quando eu lembrar posto no final do artigo) que vai utilizar só o Bazaar para manter o Ubuntu, afinal de contas a Canonical é a mantenedora do próprio Bazaar, além dela alguns outros projetos grandes como o MySQL também utilizam.

Outras ferramentas que podem ser citada são os hostings Free que cada uma das ferramentas possui.

O Mercurial tem o FreeHg, que não cheguei a testar mas parece-me que é totalmente gratuíto e deve ser destinado a projetos OpenSource.

O Git tem o Gitorious e o mais recente Github, este último bastante utilizado por toda a comunidade Ruby On Rails, desde que o Próprio Rails foi hospedado lá, além de o próprio Github ser desenvolvido em Rails. é uma Pena que o Github não tenha um gerenciamento de bugs (Bug Tracker) integrado a ele, e a opção que foi adotada inclusive pelo Rails o Lighthouse, eu particularmente não me agradei, sinceramente eu preferia o Trac ou o Próprio Redmine que também é Feito em Rails.
o Bazaar tem o Launchpad, que é totalmente gratuíto, destinado a projetos Opensource, possui um ótimo Issue Tracker integrado e mais um monte de coisas legais como os Blueprints e sistema para auxílio a internacionalização, é uma Excelente ferramenta, que na minha opinião melhor de todas aqui citadas, porém eu mesmo acho ele um pouco lento às vezes se comparado com o Github. Mas se formos levar em conta que o Github tem (no momento da escrita deste artigo) um limite de 100Mb por conta de usuário para projetos Pessoais/Públicos (Provavelmente isso deve poder ser negociado com o Pessoal do Github) Launchpad continua melhor, pois não possui limite, entretanto eu realmente gostaria que o pessoal da Canonical criasse a possibilidade de ter Contas Premium para projetos privados no Launchpad (que eu nunca vi mas pode até ser que exista, pois o launchpad em si não é OpenSource, embora partes dele sejam).

Final da história

Meu escolhido foi o Bazaar. Se eu já utilizasse apenas Linux e não tivesse mais desenvolvedores para ter que botar na cabeça todos os comandos, talvez eu tivesse optado pelo Git, embora hoje em dia depois de utilizar os dois no dia a dia acho o Bazaar realmente melhor que o Git, além do mais o Bazaar vem evoluindo rapidamente inclusive no quesito da performance que seria o seu ponto mais fraco. Em todo caso se as coisas um dia ficarem realmente lentas eu sempre terei a opção de migrar para o Git.

Hoje em dia eu particularmente utilizo o Git com bastante frequência assim como o Carlos, e assim provavelmente vamos continuar fazendo, quando se tratar de algo relacionado ao Ruby On Rails, em contrapartida nossos projetos da Empresa e pessoais, além de outros tipos de controle de versão de documentos e arquivos binários eu vou continuar utilizando o Bazaar.

Em breve estarei postando um how to, bastante sem criatividade pois pretendo refazer o artigo do Akita utilizando o Bazaar para exemplificar o uso, semelhanças e diferenças, além de mostrar que é possível trabalhar com o Bazaar em um modelo bastante aproximado, senão idêntico ao Git.

Todos os testes foram realizados em aproximadamente umas 3 semanas, não foram apenas testes de 5 minutos em cada opção de ferramenta.

Tudo que eu escrevi aqui está diretamente relacionado ao meu cenário de trabalho e experiências, provavelmente para outros cenários e pontos de vista uma das outras ferramentas citadas ou mesmo não citadas se encaixam melhor.

* Veja mais sobre controle de versão distribuído neste link (Em Inglês) e não deixe de assistir o vídeo.
** Os pacotes em Python são chamados de Eggs, seriam equivalentes aos Gems do Ruby ou mesmo aos pacotes Deb ou RPM do linux.
*** O Ambiente Windows não é preparado para desenvolvedores
**** Conversa sem sentido onde dois ou mais grupos que não tem o que fazer, discutem incansávelmente para provar que sua ferramenta é melhor que a do outro
***** Grande Ironia, Um dos maiores causadores de Blames que eu já vi foram comparativos entre Java e Python, e os Javeiros Inteligentes passam a usar uma ferramenta em Python… já os outros…. devem estar chorando.