Ry's Git Tutorial

📚 Resumo do Conteúdo

Um guia abrangente sobre controle de versão Git, passando dos fluxos básicos como preparação e confirmação para tópicos avançados como rebase interativo, colaboração remota e o funcionamento interno do banco de dados de objetos do Git.

Domine o sistema de controle de versão mais popular do mundo, desde comandos até os fundamentos internos.

Autor: Ryan Hodson

Agradecimentos: Nenhum mencionado explicitamente no material inicial.

🎯 Objetivos de Aprendizagem

1. Comparar e contrastar Sistemas Locais, Centralizados e Distribuídos de Controle de Versão.
2. Identificar as motivações históricas por trás da criação do Git para o kernel Linux.
3. Realizar a configuração básica do Git, incluindo verificação de instalação, inicialização de repositório e rastreamento de arquivos.
4. Inicializar um repositório Git e identificar o papel do diretório .git.
5. Configurar as definições globais do usuário e rastrear arquivos do projeto usando a área de preparação (staging).
6. Executar commits para criar instantâneos do projeto e revisá-los usando o histórico do repositório.
7. Navegar até commits específicos no histórico usando IDs e retornar ao estado atual do projeto.
8. Criar e gerenciar tags anotadas para identificar versões estáveis de lançamento.
9. Aplicar git revert para desfazer mudanças confirmadas especificamente, mantendo um histórico transparente.
10. Identificar, criar e alternar entre ramificações usando a CLI do Git.

🔹 Lição 1: História e Fundamentos do Controle de Revisão

Visão Geral: Esta lição traça a evolução do controle de versão desde o gerenciamento manual de arquivos até sistemas distribuídos sofisticados. Detalha as diferenças arquitetônicas entre Sistemas Locais, Centralizados e Distribuídos de Controle de Versão (VCS) e explica o contexto histórico específico que levou à criação do Git. Os alunos também aprenderão os passos fundamentais para instalar o Git e inicializar seu primeiro repositório.

Resultados de Aprendizagem:

• Comparar e contrastar Sistemas Locais, Centralizados e Distribuídos de Controle de Versão.
• Identificar as motivações históricas por trás da criação do Git para o kernel Linux.
• Realizar a configuração básica do Git, incluindo verificação de instalação, inicialização de repositório e rastreamento de arquivos.

🔹 Lição 2: Dominando os Fundamentos: Preparação e Confirmação

Visão Geral: Esta lição aborda o ciclo de vida fundamental de um repositório Git, passando de uma pasta de projeto padrão para um ambiente controlado por versão. Os alunos aprenderão a inicializar repositórios, configurar a identidade do usuário, rastrear arquivos novos e gerenciar a transição das mudanças pela área de preparação (staging) para um histórico permanentemente confirmado.

Resultados de Aprendizagem:

• Inicializar um repositório Git e identificar o papel do diretório .git.
• Configurar as definições globais do usuário e rastrear arquivos do projeto usando a área de preparação.
• Executar commits para criar instantâneos do projeto e revisá-los usando o histórico do repositório.

🔹 Lição 3: Desfazendo Mudanças e Navegando pelo Histórico

Visão Geral: Esta lição cobre as técnicas essenciais do Git para viagens no tempo dentro de um repositório, permitindo que desenvolvedores inspecionem estados passados, marquem marcos importantes e desfaçam erros com segurança. Os aprendizes dominarão a habilidade de visualizar revisões antigas sem alterações permanentes, usar tags anotadas para rotular lançamentos e distinguir entre desfazer histórico confirmado versus limpar trabalho experimental não confirmado.

Resultados de Aprendizagem:

• Navegar até commits históricos específicos usando IDs e retornar ao estado atual do projeto.
• Criar e gerenciar tags anotadas para identificar versões estáveis de lançamento.
• Aplicar git revert para desfazer mudanças confirmadas especificamente, mantendo um histórico transparente.

🔹 Lição 4: Ramificação Essencial e Mesclagem Básica

Visão Geral: Esta lição aborda o ciclo de vida fundamental das ramificações Git, passando da concepção de ramificações como linhas independentes de desenvolvimento para sua execução prática. Os alunos aprenderão a criar, navegar e visualizar histórias projetadas em bifurcações, culminando na integração do trabalho por meio de mesclagens "fast-forward" e "três vias", seguida pela limpeza de ramificações temporárias.

Resultados de Aprendizagem:

• Identificar, criar e alternar entre ramificações usando a CLI do Git.
• Interpretar diagramas de histórico bifurcado para entender a relação entre master e ramificações de funcionalidades.
• Executar e distinguir entre mesclagens "fast-forward" e "três vias".

🔹 Lição 5: Ramificação Avançada e Resolução de Conflitos

Visão Geral: Esta lição explora operações avançadas do Git necessárias diante de histórias de projeto divergentes. Cobrem os mecanismos teóricos das mesclagens de três vias, o uso prático da flag -a para commits simplificados, e a gestão de ramificações de funcionalidades de longa duração. Os alunos aprenderão a navegar interações complexas entre ramificações, resolver conflitos de mesclagem manualmente e manter a higiene do repositório através da limpeza adequada de ramificações.

Resultados de Aprendizagem:

• Explicar a diferença estrutural entre uma mesclagem "fast-forward" e uma mesclagem de três vias.
• Utilizar a flag -a para combinar preparação e confirmação de arquivos rastreados.
• Identificar e resolver conflitos de mesclagem interpretando os marcadores de conflito do Git.

🔹 Lição 6: Rebase para um Histórico de Projeto Linear

Visão Geral: Esta lição aborda as técnicas usadas para manter um histórico de projeto limpo e linear, movendo e condensando commits. Os aprendizes dominarão a transição de ramificações divergentes para uma linha temporal unificada usando rebase padrão, rebase interativo (squashing) e a capacidade de corrigir commits específicos durante o processo. Ao final deste módulo, os alunos entenderão como eliminar commits de mesclagem desnecessários e apresentar um log de commits profissional e otimizado.

Resultados de Aprendizagem:

• Mover a base de uma ramificação de funcionalidade para a ponta de outra ramificação, habilitando mesclagens "fast-forward".
• Utilizar o rebase interativo para condensar (squash) múltiplos pequenos commits em instantâneos únicos e significativos.
• Modificar commits existentes durante um rebase usando as funcionalidades edit e --amend.

🔹 Lição 7: Reescrita do Histórico e Segurança do Reflog

Visão Geral: Esta lição explora técnicas avançadas do Git para manter um histórico de projeto limpo e profissional. Os aprendizes dominarão o "Rebase Interativo" para reescrever commits passados, aprenderão o fluxo preciso para dividir commits genéricos em atualizações granulares e utilizarão o "Reflog" como uma poderosa rede de segurança para recuperar dados aparentemente perdidos.

Resultados de Aprendizagem:

• Realizar um rebase interativo para modificar, editar ou dividir commits históricos.
• Decompor um único commit genérico em múltiplos commits independentes e significativos usando git reset --mixed.
• Navegar pelo Reflog do Git para identificar e revitalizar "commits soltos" que já não estão ligados a uma ramificação.

🔹 Lição 8: Colaborando via Push e Fetch

Visão Geral: Esta lição explora os fluxos fundamentais para colaboração multiusuário no Git. Você aprenderá a criar clones independentes de repositórios, configurar identidades locais para simular diferentes usuários e estabelecer conexões "remotas" para trocar código. A lição foca nos mecanismos de puxar dados (fetch) e enviar dados (push) entre repositórios para sincronizar esforços de desenvolvimento.

Resultados de Aprendizagem:

• Clonar e Configurar: Duplicar com sucesso um repositório e definir configurações locais de usuário.
• Sincronizar Remotos: Adicionar marcadores remotos e usar fetch e merge para integrar mudanças de outros desenvolvedores.
• Gerenciar Estado Remoto: Navegar ramificações remotas e compreender o estado "HEAD desconectado" ao inspecionar código não local.

🔹 Lição 9: Modelo de Repositório Compartilhado Centralizado

Visão Geral: Esta lição aborda a transição do compartilhamento ponto a ponto de repositórios para um fluxo centralizado. Os alunos aprenderão a criar um repositório "não bare" para atuar como hub de comunicação, reconfigurar remotos para um ambiente em equipe e gerenciar a sincronização de mudanças (push e pull) entre múltiplos desenvolvedores para manter um histórico de projeto consistente.

Resultados de Aprendizagem:

• Inicializar e configurar um repositório "não bare" para servir como servidor central.
• Gerenciar conexões remotas para redirecionar fluxos locais para um centro centralizado.
• Executar um fluxo padronizado para atualizar conteúdo compartilhado e resolver histórias divergentes usando fetch, rebase e merge.

🔹 Lição 10: Modelo de Integrador Distribuído

Visão Geral: Esta lição explora a transição do controle de versão centralizado para o Modelo de Integrador Distribuído usando o Bitbucket como provedor de hospedagem. Os aprendizes progredirão desde a configuração de um repositório público até a gestão de um fluxo sofisticado onde um "Integrador" revisa e mescla contribuições de repositórios públicos de desenvolvedores colegas em uma versão oficial do projeto.

Resultados de Aprendizagem:

• Configurar uma conta no Bitbucket e estabelecer um repositório remoto público para colaboração distribuída.
• Executar o "Fluxo do Integrador" gerenciando múltiplos remotos para buscar, revisar e mesclar contribuições externas.
• Manter a sincronização entre ambientes locais privados e repositórios visíveis publicamente em uma equipe de desenvolvedores.

🔹 Lição 11: Comunicação e Fluxos Baseados em Patches

Visão Geral: Esta lição aborda o ciclo de vida da colaboração baseada em patches no Git, um método usado para compartilhar commits individuais entre desenvolvedores sem exigir acesso compartilhado a um repositório central. Os alunos aprenderão a gerar arquivos de patch a partir de commits locais, distribuí-los por e-mail e integrar patches recebidos na branch principal do projeto.

Resultados de Aprendizagem:

• Gerar arquivos de patch individuais a partir de commits específicos ou ramificações usando git format-patch.
• Aplicar arquivos de patch externos a um repositório local usando o comando git am e redirecionamento de entrada padrão.
• Executar um fluxo completo de integração, incluindo testar patches em branches temporárias e mesclá-los na branch master.

🔹 Lição 12: Ferramentas Git, Hooks e Diff Avançados

Visão Geral: Esta lição aborda comandos essenciais do Git e técnicas de personalização para gerenciamento avançado de repositórios. Os alunos aprenderão a exportar e compartilhar repositórios por meio de arquivamento e empacotamento, manter um espaço de trabalho limpo usando .gitignore e stash, automatizar fluxos de trabalho via hooks do Git e otimizar a experiência de linha de comando com comparações de diff avançadas e aliases personalizados.

Resultados de Aprendizagem:

• Diferenciar e executar exportações de repositório usando arquivamento (sem histórico) e empacotamento (com histórico completo).
• Configurar padrões de exclusão de arquivos e gerenciar mudanças temporárias em andamento.
• Implementar scripts de automação no sistema de hooks interno do Git e agilizar fluxos de trabalho usando aliases de configuração.

🔹 Lição 13: Git Plumbing: O Banco de Dados de Objetos Interno

Visão Geral: Esta lição mergulha abaixo dos comandos "porcelana" amigáveis do Git para explorar seu "plumbing" — o banco de dados de objetos de baixo nível. Você aprenderá como o Git usa quatro tipos distintos de objetos (Blobs, Trees, Commits e Tags) e checksums SHA-1 para registrar o histórico do projeto. Ao final deste módulo, você entenderá como manipular manualmente o índice e o banco de dados de objetos para criar commits sem a interface de alto nível padrão.

Resultados de Aprendizagem:

• Definir e distinguir entre os quatro tipos de objetos do Git: Blobs, Trees, Commits e Tags.
• Explicar o papel de HEAD e referências de ramificações ao apontar para objetos de commit específicos.
• Demonstrar o fluxo "plumbing": preparar manualmente arquivos, escrever árvores e criar objetos de commit.