Sistema de Controle de Versão

Um sistema de controle de versão (VCS) registra as alterações em um conjunto de arquivos ao longo do tempo para que você possa recuperar qualquer versão específica posteriormente. Esta página explica o que é controle de versão, por que equipes de software dependem dele, as três famílias de ferramentas VCS (local, centralizado e distribuído) e os benefícios concretos que cada uma oferece. É a base conceitual para tudo neste livro — uma vez que você entende por que o controle de versão existe, comandos como git init, git commit e git branch fazem muito mais sentido.

O que é Controle de Versão?

Controle de versão é um sistema que registra alterações no código-fonte (ou em qualquer conjunto de arquivos) para que uma equipe possa gerenciar a evolução desse código ao longo do tempo. Em vez de sobrescrever arquivos e perder o estado anterior, o sistema armazena cada alteração significativa como uma revisão à qual você pode retornar.

Concretamente, o controle de versão permite:

• Viajar no tempo — restaurar qualquer versão anterior de um arquivo ou do projeto inteiro.
• Ver quem alterou o quê e por quê — cada revisão carrega um autor, uma data e uma mensagem.
• Trabalhar em paralelo — separar linhas de trabalho independentes em branches e combiná-las posteriormente com um merge.
• Comparar versões — visualizar as diferenças exatas entre dois pontos no histórico com um diff.

Por que Isso Importa

O controle de versão é essencial a partir do momento em que mais de uma pessoa — ou mais de uma máquina, ou mesmo apenas você ao longo do tempo — toca em uma base de código. Ele permite que vários desenvolvedores trabalhem de forma independente sem sobrescrever o trabalho uns dos outros, para depois integrar essas alterações de forma rastreável. Ele também transforma "eu quebrei algo e não sei o quê" em uma pergunta que você pode responder: é possível encontrar a alteração exata que introduziu um bug e desfazer apenas essa mudança.

Mesmo em um projeto individual, o controle de versão oferece uma rede de segurança. Você pode experimentar livremente, sabendo que todo estado funcional está salvo e pode ser recuperado.

Sistemas de Controle de Versão (VCS)

Um Sistema de Controle de Versão (VCS) — também chamado de Gerenciamento de Código-Fonte (SCM) ou Sistema de Controle de Revisão (RCS) — é a ferramenta de software que implementa o controle de versão: rastreia alterações, armazena o histórico e coordena a colaboração.

Três Tipos de Sistemas de Controle de Versão

Historicamente, as ferramentas VCS se dividem em três famílias, cada uma resolvendo um problema que a anterior deixou em aberto.

1. Sistemas de Controle de Versão Locais

Um VCS local mantém o histórico completo em um banco de dados simples em uma única máquina. Foi criado para evitar erros cotidianos como editar o arquivo errado ou perder uma versão anterior ao copiar diretórios manualmente. Uma das ferramentas locais mais populares é o RCS (Revision Control System), ainda distribuído hoje. O RCS armazena conjuntos de patches (as diferenças entre versões) para que possa recriar qualquer arquivo como ele estava em qualquer ponto no tempo.

A limitação é óbvia: o histórico fica em um único computador, portanto não oferece colaboração real nem proteção caso aquele disco falhe.

2. Sistemas de Controle de Versão Centralizados

Um VCS centralizado (CVCS) armazena todos os arquivos versionados em um único servidor central, e os clientes "fazem checkout" dos arquivos a partir desse único ponto. Isso resolveu a colaboração: todos podiam ver, em certa medida, o que os outros estavam fazendo, e os administradores tinham um ponto central de controle. Por muitos anos, esse foi o padrão. Exemplos comuns são CVS, Subversion (SVN) e Perforce.

A desvantagem é o ponto único de falha. Se o servidor central ficar fora do ar, ninguém pode fazer commit ou colaborar; se o disco for perdido sem backup, todo o histórico do projeto pode ser perdido junto.

3. Sistemas de Controle de Versão Distribuídos

Em um VCS distribuído (DVCS), cada cliente não apenas faz checkout dos arquivos mais recentes — ele espelha completamente o repositório, incluindo o histórico completo. Se o servidor falhar, o clone de qualquer cliente pode ser enviado de volta para restaurá-lo. Isso também torna a maioria das operações rápidas e possíveis offline, pois o histórico completo é local. Exemplos incluem Git, Mercurial, Bazaar e Darcs.

Este é o modelo que o Git utiliza, e é por isso que você pode fazer commit, criar branches, visualizar o histórico e fazer diff sem nenhuma conexão de rede. O restante deste livro aborda o Git em profundidade — comece com O que é Git? e instalando o Git.

Benefícios dos Sistemas de Controle de Versão

Os principais benefícios de um VCS são:

1. Histórico de alterações a longo prazo. Toda criação, modificação e exclusão de um arquivo é registrada durante a vida útil do projeto. Isso permite retornar a uma versão anterior para analisar bugs e corrigir problemas.
2. Branching e merging. O branching permite que os desenvolvedores trabalhem de forma independente sem interferir uns nos outros. O merging reúne esse trabalho e evidencia quaisquer conflitos para que possam ser resolvidos de forma deliberada.
3. Rastreabilidade. Você pode rastrear cada alteração, anotá-la com uma mensagem descrevendo seu propósito e conectá-la a ferramentas de gerenciamento de projetos e rastreamento de bugs.

Controle de Versão na Prática

Você não precisa de um servidor ou de uma equipe para ver o controle de versão funcionando — o Git rastreia o histórico diretamente na sua própria máquina. Os comandos abaixo são executados inteiramente de forma local: eles criam um repositório, registram duas versões de um arquivo e depois pedem ao Git o histórico desse arquivo. Experimente-os em um terminal após instalar o Git.

# Create a fresh project and turn it into a Git repository
mkdir vcs-demo && cd vcs-demo
git init -q

# Tell Git who is making the changes (required for a commit)
git config user.email "[email protected]"
git config user.name "You"

# Record the first version
echo "line one" > notes.txt
git add notes.txt
git commit -q -m "Add notes.txt"

# Change the file and record a second version
echo "line two" >> notes.txt
git commit -q -am "Add a second line"

# Ask version control for the history of this file
git log --oneline

A saída de git log --oneline lista duas revisões, da mais recente para a mais antiga — cada uma com um hash de commit curto e a mensagem que você escreveu:

3f8a1c2 Add a second line
9b2e4d7 Add notes.txt

(Seus hashes serão diferentes, pois são calculados a partir do conteúdo e do timestamp.) Esse histórico é o coração do controle de versão: cada versão é salva, rotulada e recuperável. Para se aprofundar, consulte git log e git commit.

Prática