O documento apresenta um roteiro para ensinar conceitos e comandos básicos do Git. Após introduzir o Git e sua utilidade, o roteiro explica conceitos como versionamento distribuído e commits atômicos. Em seguida, ensina como clonar um repositório, criar commits, desfazer commits, atualizar o repositório local e verificar logs. Finalmente, fornece dicas sobre boas práticas e esclarece pontos adicionais sobre Git.

1. Git – Hands On
Rafael S Bezerra
Paulo K Mello

2. Roteiro
• Introdução
• Conceitos Básicos
• Clonar o repositório – git clone
• Criar um commit – git add / commit
• Desfazer um commit – git checkout / reset
• Atualizar o repositório local – git pull / fetch / merge
• Exercício: um monte de commits
• Ver o estado do repo – git log / diff
• Conclusões

3. Introdução
Por que eu aprenderia git?
Em que isso vai ser útil?
Não é melhor só colocar o projeto no Dropbox? Dá menos trabalho...

4. Introdução
• Pra que git é útil?
• Controle de Versão
– Controlar mudanças
– Nomear e armazenar versões
– Entender a história
– Backup
– Colaboração

5. Introdução
• Perguntas importantes:
– Quem fez isso?!
– Mas por que?! O que se passou na cabeça dessa
pessoa?
– Desde quando esse bug existe?!
– Sem condições... Vou desfazer essa bagunça aqui
– Agora tá bom. Fechar uma versão.

6. Introdução
Fazer parte da comunidade
mundial de devs

7. Introdução
• Essa comunidade não consegue decidir:
– Qual sistema operacional usar
– Qual editor de texto usar
– Que linguagens usar pra que
– camelCase ou underscore_separated

8. Introdução
Mas toda essa comunidade de
gente exigente usa git
A maioria dos projetos open-
source que vocês conhecem
estão versionados usando git
(e no github)

9. Introdução

10. Conceitos Básicos
• AKA: expressões semi-confusas que você vai
ver quando tiver lendo sobre git
Versionamento distribuído
Commits atômicos
Árvore de commits

11. Conceitos Básicos
github.com/
Quem ainda não tem conta, crie!
git config --global user.name “<name>”
git config --global user.email my@email.com

12. Clonar o Repositorio
git clone http://github.com/rafaelsbz/db-git-handson
cd db-git-handson
ls -a
git status
git remote -v

13. Clonar o Repositorio
• Preparando o projeto para a IDE:
– gradle eclipse
• Importando o projeto no Eclipse:
– Importe o projeto
• File -> Import -> Existing Projects Into Workspace
• Select Root Directory -> Browse
• Escolha o diretório developer/db-git-handson
• Ok -> Finish

14. Commit
• Modificar o código e versionar nossa mudança
• Principais conceitos:
– Staging Area
– Working Copy
• Comandos:
– git add
– git commit
– git push

15. Commit
• Passos (Prestem atenção!)
– Fazer alterações
– Ver o que alteramos: git status
– Escolher o que vai no commit: git add
– Criar o commit: git commit
– Ver o commit criado: git log
– Ver que meu repositório está à frente do remoto:
git status

16. Commit
Enviar nossas mudanças pro repositório remoto
IMPORTANTE:
Somente nós na frente vamos fazer isso
(por enquanto :)

17. Commit
git push origin master
Repositório
remoto
Branch

18. Desfazendo o Commit
git reset --hard HEAD~1
Reseta história e
arquivos
Commit atual – 1
Ou seja, pro commit anterior

19. Atualizar o repositório
• Pegar o que modificaram no github (repo
remoto)
• Duas maneiras:
– git pull
• Um comando só. Abstrai a lógica dos comandos abaixo
– git fetch -> git merge ou git rebase
• Como o pull funciona por trás dos panos
• Modo mais seguro de você entender o que está
trazendo pro seu repositório!

20. Atualizar o repositório
git pull
Se você viu “Fast Forward”, tudo OK!
git log
Você deve ver o commit novo!

21. Atualizar o repositório
git fetch
Veja que o branch origin/master foi atualizado
git rebase origin/master
Fast Forward = OK!
git log
Você deve ver o commit novo!

22. Atualizar o repositório
Demonstração: Diferença entre rebase e merge

23. Simulando um Cenário Real
• Usando o eclipse, todos vocês vão criar arquivos na pasta
src/main/resources/
– Botão direito na pasta
– New -> File
– Dê um nome
– Escreva alguma coisa
• Depois vocês vão fazer um commit com esse(s) arquivos
– Execute o projeto no eclipse ou usando o comando gradle run no
terminal pra (tentar :) ver que ele imprimiu o conteúdo do seu arquivo
• Finalmente, vocês vão tentar fazer push desses arquivos
– Se alguém tiver feito push antes, vocês terão que atualizar o
repositório antes
• Nós temos tempo limitado pra isso
– Se alguém não conseguir, tudo bem!
– Crie um repo no github e vá tentando em casa 

24. Simulando um Cenário Real
• git status
– Ver o que está acontecendo. Use o tempo todo 
• git fetch
– Atualiza a sua visão do repositório remoto (origin/master)
• git rebase origin/master
– Atualiza o seu branch master em relação ao remoto (origin)
– Lembre-se: você não pode atualizar seu branch se tiver mudanças
não commitadas
• git add <arquivo>
– Adiciona mudanças na staging área
• git commit –m “mensagem”
– Cria um commit com todas as mudanças adicionadas atualmente
• git push origin master
– Envia para o github. Tenta enviar o estado atual do seu repo como o
estado atual.
– Vai falhar se alguém fez push antes. Nesse caso, atualize seu repo.

25. Explorando Logs
git log --name-status
Exibe o nome dos arquivos alterados no commit
git log <commit1> .. <commit2>
Mostra os commits a partir do <commit1> até o <commit2>
git log <commit1> .. HEAD
Mostra os commits a partir do <commit1> até o atual

26. Explorando Logs
git diff
Mostra as diferenças textuais entre um commit e outro
git diff HEAD~1 HEAD
Diferença entre o commit anterior e o atual
git diff <commit1> .. HEAD
Diferença entre um commit arbitrário e o atual

27. Conclusões
• Algumas boas práticas:
– Mensagens de commit extremante claras
• Primeira linha resumindo o commit
• Segunda linha em branco
• Texto explicando o que você fez, seu raciocínio,
possíveis problemas, etc..
– Não modificar história publicada
• Ou seja, não usar git push --force
• git revert se for necessário desfazer as alterações de
um commit

28. Conclusões
• Mais boas práticas:
– Nunca versionar arquivos gerados
automaticamente
• Exemplos:
– Arquivos .class gerados na compilação
– Documentação gerada automaticamente
• Coloque esses arquivos no seu .gitignore e seja feliz 
– Não versionar binários / código fonte de
dependências
• Não crie uma pasta /lib com um monte de .jars dentro!
• Use o gerenciador de dependências pra sua linguagem
e versione o arquivo de configuração dele

29. Conclusões
• Alguns pontos interessantes que não cobrimos
aqui:
– Simples
• Criar um repositório (git init)
• .gitignore
• Pull requests
– Um pouco mais complexos:
• Branches
• Commits locais e squash de commits
• Múltiplos repositórios remotos
• Configuração de editor e ferramentas de diff/merge
• Resolução de conflitos

30. Conclusões
• Vocês praticaram:
– Clonar um repo existente
– Commitar
– Atualizar o repositório local
– Enviar commits para um repositório remoto
– Entender o que está acontecendo na história do
seu repo

31. Conclusões
• Minha sugestão pessoal é vocês começarem a
usar git nos projetos pessoais de vocês
– Trabalhos individuais
• Usar commits para organizar blocos de trabalho
• Criar branches pra coisas experimentais
• Usar repositórios remotos para backup
– Trabalhos em grupo
• Criar um repositório compartilhado

32. Informações Adicionais
• Sobre git:
– Bitbucket:
• Outro servidor de repositórios gratuito
• Repositórios privados / mais controle de acesso
– Tutorial do github:
• https://try.github.io/
• Sobre o Setup:
– Linux Debian
– Java: openjdk 8.0 + Gradle
– Terminal: zshell + oh-my-zsh
– Eclipse 

33. Obrigado
Dúvidas? Feedbacks?
Rafael Santos Bezerra
bezerrar@dbserver.com.br
rafaelsbz@gmail.com
github.com/rafaelsbz
Paulo Eduardo Kopzinski Mello
mellop@dbserver.com.br
eduardo@kopzinski.com.br
github.com/kopzinski