GIT: Do Controle de Versão à Colaboração Inteligente

Introdução

O Git é um sistema de controle de versão conhecido como VCS (do inglês, version control system) e vem sendo amplamente utilizado no desenvolvimento de códigos para software, sites, aplicativos, aprendizado de máquina, inteligência artificial, etc. Ele foi criado por Linus Torvalds em 2005 para ajudar no desenvolvimento do kernel do Linux, mas desde então se tornou uma ferramenta essencial em muitos projetos de software.

Esta ferramenta permite que os desenvolvedores acompanhem as alterações feitas em seus arquivos ao longo do tempo, facilitando o trabalho colaborativo e o gerenciamento eficiente de versões de um projeto. O sistema do Git registra todas as alterações feitas nos arquivos, permitindo que os desenvolvedores rastreiem quem fez cada alteração, quando foi feita e seu motivo.

Além disso, o Git possui uma ampla gama de recursos, como ramificações (branches) para o desenvolvimento paralelo, fusão (merge) das ramificações, resolução de conflitos e integração com serviços de hospedagem como o GitHub.

A adoção generalizada do Git e a integração com várias plataformas de desenvolvimento, como o GitHub, tornam-no uma escolha adequada para o controle de versão. Além disso, à medida que mais empresas adotam práticas de DevOps e integração contínua / entrega contínua (CI/CD), o Git, com suas características de ramificação e fusão, torna-se uma ferramenta essencial. O Git também é altamente escalável, o que significa que pode acomodar projetos que vão desde pequenos aplicativos individuais até grandes projetos corporativos.

Essa representação facilita a compreensão do ciclo de versionamento e colaboração em projetos com Git.

Como Começar a Usar o Git

Instalação

Windows: visite o site oficial do Git https://git-scm.com e clique no botão de download para Windows e execute o arquivo.

macOS: se você usa o macOS, pode instalar o Git usando o gerenciador de pacotes Homebrew. Primeiro, instale o Homebrew abrindo o Terminal e executando alguns comandos.

Linux: se você é usuário do Ubuntu ou Debian, o Git provavelmente está disponível via apt. Para instalá-lo, abra um terminal e execute: sudo apt-get install git.

Configurações iniciais: nome e email

Ao utilizar o Git, é recomendável configurar seu nome e endereço de e-mail. Essas informações são registradas nos commits (confirmações) que você realiza em um repositório Git. Existem algumas razões pelas quais você deve fornecer esses detalhes para identificação do autor e rastreamento de contribuições.

Para configurar seu nome e endereço de e-mail no Git, você pode utilizar os seguintes comandos no terminal:

# Configurar o nome de usuário 
git config --global user.name "Seu Nome"

# Configurar o e-mail do usuário 
git config --global user.email "seu@email.com"

Essas configurações são fundamentais para associar suas futuras alterações ao seu perfil.

Comandos UNIX no GIT

O Git foi originalmente desenvolvido para ser usado no Linux, um sistema operacional do tipo Unix, por isso é natural que ele use uma interface de linha de comando baseada em Unix. Abaixo algumas funções úteis:

• ls: Lista o conteúdo do diretório corrente;
• pwd: significa “print working directory”, este comando retorna o caminho absoluto do diretório atual;
• cd: significa “change directory”e é usado para mudar o diretório atual. Em Unix, cd . representa o diretório atual e cd .. representa o diretório pai;
• touch: atualiza a data de um arquivo (o cria, se não existir).

Branches

No Git, uma branch é uma linha de desenvolvimento separada que permite que você trabalhe em recursos ou correções de bugs sem interferir no código principal. Cada branch é uma ramificação independente do histórico de commits e pode ser mesclada (merged) com outras branches posteriormente. As branches são úteis para organizar o trabalho em equipe, permitindo que várias pessoas trabalhem em diferentes partes do projeto simultaneamente.

Aqui estão alguns dos principais comandos relacionados a branches no Git, juntamente com suas descrições:

• git branch: Exibe uma lista de todas as branches no repositório. O asterisco (*) indica a branch atualmente ativa.
• git branch <nome_branch>: Cria uma nova branch com o nome especificado.
• git switch <nome_branch>: É um comando projetado para a tarefa de mudar de branch, simplificando o uso em relação ao git checkout. O git switch não executa ações adicionais, apenas muda a branch atual. Ele foi introduzido nas versões mais recentes e que, para versões antigas, git checkout ainda é necessário.
• git switch -c <nome_branch>: cria uma nova branch a partir da branch atual e muda para ela, tudo em um único comando, permitindo que você crie e mude para uma nova branch de forma rápida e conveniente.
• git merge <nome_branch>: Incorpora as alterações da branch especificada na branch atual. Isso cria um novo commit de merge no histórico.
• git branch -d <nome_branch>: Exclui a branch especificada após mesclá-la com sucesso em outra branch.
• git branch -D <nome_branch>: Força a exclusão da branch especificada, mesmo que as alterações não tenham sido mescladas.
• git branch -m <nome_antigo> <nome_novo>: Renomeia a branch especificada.
• git branch -r: Exibe uma lista das branches remotas disponíveis.
• git push <origin> <nome_branch>: Envia a branch especificada para o repositório remoto.
• git pull <origin> <nome_branch>: Atualiza a branch local com as alterações mais recentes do repositório remoto.
• git log: é um comando usado no sistema de controle de versão Git que exibe um histórico de commits que levaram ao estado atual do código. Ele mostra o autor, a data e a mensagem do commit, ajudando a rastrear as mudanças e entender a evolução do projeto.

Diagrama representando a criação de uma nova branch a partir de um commit específico, onde o desenvolvimento segue em paralelo à branch principal (main).

Outros comandos

• git commit -a -m: adiciona automaticamente todas as alterações nos arquivos rastreados e faz um commit com uma mensagem específica, permitindo que você realize o commit rapidamente sem precisar usar o comando git add separadamente;
• git init: cria um novo repositório do Git. Ele pode ser usado para converter um projeto existente e não versionado em um repositório do Git ou inicializar um novo repositório vazio.
• git diff branch1..branch2: Compara a ponta das duas ramificações (branch), para visualizar as modificações;
• git --version: isso deve retornar a versão do Git que você instalou;
• git clone [URL]: Clona um repositório remoto para o seu ambiente local.​
• git add [arquivo]: Adiciona um arquivo específico à área de stage (preparação para commit).​
• git status: Exibe o estado atual do repositório, mostrando quais arquivos foram modificados ou estão em stage.
• ctrl + l: Atalho para limpar o terminal.

Rebasing x Merging

Rebasing” e “Merging” são duas estratégias diferentes no Git para integrar mudanças de uma branch (ramificação) para outra. Ambos são usados para manter o seu código sincronizado com o trabalho de outros desenvolvedores, mas funcionam de maneiras ligeiramente diferentes e são melhores em situações diferentes.

• Rebasing (Rebase): O comando git rebase move ou combina uma sequência de commits para uma nova base de commit. Ele é útil para fazer sua feature branch “atualizada” com as últimas mudanças de outra branch (como a main ou master). Com o rebase, os commits da feature branch são aplicados na branch base, um por um, como se eles tivessem sido criados de novo. Isso resulta em um histórico de commits linear, o que pode ser mais fácil de entender.
• Merging (Merge): O comando git merge pega o conteúdo de uma branch de origem e a integra com a branch de destino. Um novo commit de merge é criado que aponta para os dois commits, preservando o histórico de commits e a relação entre as branches. Isso mantém a história completa do projeto, incluindo todas as ramificações e mesclagens, mas pode ser mais difícil de navegar devido à sua não linearidade.
• 
  

A diferença principal entre os dois (rebase e merge) é que o rebase cria um histórico de commits linear, “recriando” os commits, enquanto o merge preserva o histórico exato e cria um novo commit de merge. A escolha entre um e outro depende de fatores como a complexidade do projeto, a necessidade de manter um histórico limpo e linear versus um histórico completo e exato, e as preferências da equipe.

O comando git rebase -i HEAD é utilizado para iniciar um processo de rebase interativo. O rebase interativo é uma funcionalidade do Git que permite modificar uma sequência de commits existente de várias formas. A opção -i no comando significa “interativo”, o que significa que o Git abrirá um editor de texto com uma lista dos últimos commits, permitindo que você escolha exatamente o que quer fazer com cada um.

O termo HEAD é uma referência ao commit mais recente na branch atual. Portanto, git rebase -i HEAD começará um rebase interativo que, por padrão, não inclui nenhum commit, pois você está tentando rebase na mesma posição do HEAD. Normalmente, você especificaria um número de commits antes do HEAD ou uma referência a outro commit, como HEAD~3 ou HEAD^, para iniciar um rebase interativo dos últimos 3 commits ou do último commit, respectivamente.

Durante um rebase interativo, você pode fazer várias coisas, como:

• pick: usar um commit como está.
• reword: usar o commit, mas alterar a mensagem do commit.
• edit: usar o commit, mas parar para que você possa modificar os arquivos e/ou o commit.
• squash: usar as alterações do commit, mas mesclá-las com o commit anterior.
• fixup: como “squash”, mas descarta a mensagem do commit.
• drop: descartar o commit. Essa flexibilidade faz do rebase interativo uma ferramenta poderosa para limpar o histórico de commits antes de compartilhar suas alterações com outros.

Exemplo prático: Vamos supor que você criou uma branch chamada nova-funcionalidade e quer mesclar com a main.

# Passo 1: Volte para a branch principal
 git checkout main

# Passo 2: Mescle a branch de funcionalidade 
git merge nova-funcionalidade

Se não houver conflitos, o Git cria um commit de mesclagem automática . Caso haja conflitos, ele vai te avisar para resolver manualmente antes de continuar.

Use merge ao colaborar com outras pessoas, pois ele mantém um histórico documentado e rastreável, incluindo de onde vieram as mudanças.

Fluxo visual de um merge no Git, mostrando a divergência de uma branch de funcionalidade a partir da base comum, com posterior junção à branch principal por meio de um commit de merge.

Git vs. GitHub

Embora frequentemente usados em conjunto, Git e GitHub são ferramentas distintas:​

• Git: Sistema de controle de versão que gerencia o histórico de alterações do código.​
• GitHub: Plataforma online que hospeda repositórios Git, facilitando a colaboração e o compartilhamento de projetos.​ Enquanto o Git opera localmente no seu computador, o GitHub fornece uma interface web para armazenar e gerenciar repositórios remotamente.

Boas Práticas na Organização de Repositórios Git

Para manter um repositório organizado e eficiente:

• README detalhado: Inclua um arquivo README.md com informações sobre o projeto, instruções de uso e como contribuir.​
• .gitignore: Utilize um arquivo .gitignore para especificar quais arquivos ou pastas não devem ser versionados, como arquivos temporários ou de configuração local.​
• Commits frequentes e descritivos : Realize commits pequenos e frequentes com mensagens claras descrevendo as alterações realizadas.
• Uso de branches: Crie branches para desenvolver novas funcionalidades ou correções, mantendo o código principal estável.​ Revisões de código (Code Reviews): Antes de mesclar uma branch, realize revisões de código para garantir a qualidade e identificar possíveis problemas.

Erros Comuns com Git (e como evitar)

Durante o aprendizado ou até mesmo no uso diário do Git, alguns erros são bastante comuns e podem comprometer o fluxo de trabalho. Abaixo estão os mais frequentes e como evitá-los:

Modificar direto na main

• Trabalhar diretamente na branch principal pode causar conflitos ou problemas no código principal. Sempre crie uma nova branch para cada funcionalidade ou correção:

git checkout -b nova-funcionalidade

Mensagens de commit pouco descritivas

• Evite commits com mensagens genéricas como “atualizações” ou “teste”. Prefira descrições claras e objetivas:

git commit -m "ajuste: corrige bug de login na tela inicial"

Ignorar o arquivo .gitignore

• Ao não configurar esse arquivo, arquivos desnecessários (como pastas de dependências ou configurações locais) podem ser versionados. Crie um .gitignore adequado logo no início do projeto.

Dar push sem antes dar pull

• Subir alterações sem atualizar o repositório local pode causar conflitos. Antes de dar push, lembre-se de sincronizar com:

git pull origin main

Forçar push sem entender os riscos

• O comando --force pode sobrescrever o trabalho de outras pessoas. Use apenas quando tiver certeza do que está fazendo — e, de preferência, em branches pessoais.

Não configurar nome e e-mail no Git

• Sem essa configuração, seus commits não serão corretamente identificados:

git config --global user.name "Seu Nome"
git config --global user.email "seu@email.com"

Evitar esses deslizes ajuda a manter o repositório limpo, seguro e fácil de colaborar. Com a prática, essas boas práticas se tornam parte do seu dia a dia no Git!

Recursos e Documentações Úteis:

Documentação Oficial do Git

Guia de Branching e Merging Melhores

Melhores Práticas para Repositórios

GitHub Diferença entre Git e GitHub

Conclusão

💡 Minha experiência pessoal com Git:

Comecei a explorar o Git recentemente, ainda na faculdade, quando precisava salvar diferentes versões de projetos. No início, tive receio de usar o terminal, mas aos poucos fui entendendo como ele me ajudava a organizar minhas ideias e colaborar com colegas. Hoje, mesmo sendo júnior, uso Git para meus estudos e projetos e já não vivo sem. Ele também tem sido essencial na construção do meu portfólio de projetos, que estou montando com carinho para aumentar minhas chances de conquistar uma oportunidade profissional na área.

Dominar o Git é fundamental para qualquer desenvolvedor que deseja trabalhar de forma eficiente e colaborativa. Ao compreender seus principais comandos, diferenças em relação ao GitHub e adotar boas práticas na organização de repositórios, você estará preparado para contribuir em projetos de qualquer escala.

Artigo feito por Dayane Teodoro, apaixonada em versões e por tornar a tecnologia acessível para todos.

#GIT #Versionamento #Tecnologia #BoaPrática #Colaboração Controle de versão #Repositórios remotos #Colaboração em equipe #Fluxo de trabalho Git