Use o código e tenha 10% de desconto!

Controlando versões com Git e GitHub

Alexandre Aquiles, Rodrigo Ferreira

Sumário

  • 1 - Introdução
    • 1.1 - Mantendo o histórico do código
    • 1.2 - Trabalhando em equipe
    • 1.3 - Sistemas de controle de versão
    • 1.4 - Controle de versão rápido e confiável com Git
    • 1.5 - Hospedando código no GitHub
    • 1.6 - O processo de escrita desse livro
  • 2 - Tour prático
    • 2.1 - Instalando e configurando o Git
    • 2.2 - Criando um arquivo texto para versionarmos
    • 2.3 - Versionando seu código com Git
    • 2.4 - Compartilhando seu código através do GitHub
  • 3 - Trabalhando com repositório local
    • 3.1 - Criando um repositório local
    • 3.2 - Rastreando arquivos
    • 3.3 - Gravando arquivos no repositório
    • 3.4 - Verificando o histórico do seu repositório
    • 3.5 - Verificando mudanças nos arquivos rastreados
    • 3.6 - Removendo arquivos do repositório
    • 3.7 - Renomeando e movendo arquivos
    • 3.8 - Desfazendo mudanças
  • 4 - Trabalhando com repositório remoto
    • 4.1 - Repositório remoto
    • 4.2 - Adicionando o repositório remoto
    • 4.3 - Enviando commits para o repositório remoto
    • 4.4 - Clonando o repositório remoto
    • 4.5 - Sincronizando o repositório local
    • 4.6 - Protocolos suportados pelo Git
  • 5 - Hospedando o repositório no GitHub
    • 5.1 - Serviços de hospedagem de projetos
    • 5.2 - GitHub: a rede social dos desenvolvedores
    • 5.3 - Encontrando projetos e visualizando o código-fonte
    • 5.4 - Criando um usuário no GitHub
    • 5.5 - Criando o repositório do projeto
    • 5.6 - Enviando os commits do projeto para o GitHub
    • 5.7 - Clonando o repositório hospedado no GitHub
    • 5.8 - Colaborando com projetos open source
  • 6 - Organizando o trabalho com branches
    • 6.1 - A branch master
    • 6.2 - Criando uma branch
    • 6.3 - Trocando de branch
    • 6.4 - Deletando uma branch
    • 6.5 - Comitando código em uma nova branch
    • 6.6 - Voltando para o master e fazendo uma alteração
    • 6.7 - Mesclando alterações
  • 7 - Trabalhando em equipe com branches remotas
    • 7.1 - Branches remotas
    • 7.2 - Compartilhando branches
    • 7.3 - Obtendo novas branches remotas em outros repositórios
    • 7.4 - Enviando commits para o repositório central
    • 7.5 - Obtendo commits de uma branch remota
    • 7.6 - Mesclando branches remotas e locais
    • 7.7 - Deletando branches remotas
  • 8 - Controlando versões do código com tags
    • 8.1 - Criando, listando e deletando tags
    • 8.2 - Mais informações com tags anotadas
    • 8.3 - Compartilhando tags com a sua equipe
  • 9 - Lidando com conflitos
    • 9.1 - Mesclando mudanças em um mesmo arquivo sem conflitos
    • 9.2 - Conflitos após um merge com mudanças em um mesmo arquivo
    • 9.3 - Resolvendo conflitos após um rebase
    • 9.4 - Usando uma ferramenta para resolver conflitos
  • 10 - Maneiras de trabalhar com Git
    • 10.1 - Utilizando só a branch master com um repositório central
    • 10.2 - Utilizando branches por funcionalidade com um repositório central
    • 10.3 - Utilizando branches por etapa de desenvolvimento com um repositório central
    • 10.4 - Colaborando com projetos open source com Fork e Pull Request
    • 10.5 - Organizando projetos open source gigantescos com Ditador e Tenentes
  • 11 - Apêndice ─ GitHub no Windows
    • 11.1 - Instalando o GitHub for Windows
    • 11.2 - Criando um novo repositório
    • 11.3 - Efetuando commits no repositório
    • 11.4 - Detalhando os commits
    • 11.5 - Enviando o repositório para o GitHub
    • 11.6 - Trabalhando com branches
Capítulo1

Introdução

1.1 - Mantendo o histórico do código

Vida de programador não é fácil. Há sempre uma pressão por entregas rápidas de novas funcionalidades. Mas, apesar da pressa, é necessário prestar atenção no que estamos fazendo, mesmo se a alteração for pequena. Ao mexermos em um código existente é importante tomarmos cuidado para não quebrar o que já funciona.

Por isso, queremos mexer o mínimo possível no código. Temos medo de remover código obsoleto, não utilizado ou até mesmo comentado, mesmo que mantê-lo já nem faça sentido. Não é incomum no mercado vermos código funcional acompanhado de centenas de linhas de código comentado.

Sem dúvida, é interessante manter o histórico do código dos projetos, para entendermos como chegamos até ali. Mas manter esse histórico junto ao código atual, com o decorrer do tempo, deixa nossos projetos confusos, poluídos com trechos e comentários que poderiam ser excluídos sem afetar o funcionamento do sistema.

Seria bom se houvesse uma maneira de navegarmos pelo código do passado, como uma máquina do tempo para código...

1.2 - Trabalhando em equipe

Mas, mesmo que tivéssemos essa máquina do tempo, temos outro problema: muito raramente trabalhamos sozinhos.

Construir um sistema em equipe é um grande desafio. Nosso código tem que se integrar de maneira transparente e sem emendas com o código de todos os outros membros da nossa equipe.

Como podemos detectar que estamos alterando o mesmo código que um colega? Como mesclar as alterações que fizemos com a demais alterações da equipe? E como identificar conflitos entre essas alterações? Fazer isso manualmente, com cadernetas ou planilhas e muita conversa, parece trabalhoso demais e bastante suscetível a erros e esquecimentos.

Seria bom que tivéssemos um robô de integração de código, que fizesse todo esse trabalho automaticamente...

1.3 - Sistemas de controle de versão

Existem ferramentas que funcionam como máquinas do tempo e robôs de integração para o seu código. Elas nos permitem acompanhar as alterações desde as versões mais antigas. Também é possível detectar e mesclar alterações nos mesmos arquivos, além de identificar conflitos, tudo de maneira automática.

Essas ferramentas são chamadas de sistemas de controle de versão.

Nesse tipo de ferramenta, há um repositório que nos permite obter qualquer versão já existente do código. Sempre que quisermos controlar as versões de algum arquivo, temos que informar que queremos rastreá-lo no repositório. A cada mudança que desejamos efetivar, devemos armazenar as alterações nesse repositório.

Alterações nos mesmos arquivos são mescladas de maneira automática sempre que possível. Já possíveis conflitos são identificados a cada vez que obtemos as mudanças dos nossos colegas de time.

Desde a década de 1990, existe esse tipo de ferramenta. Alguns exemplos de sistemas de controle de versão mais antigos são CVS, ClearCase, SourceSafe e SVN (que ainda é bastante usado nas empresas).

Em meados da década de 2000, surgiram sistemas de controle de versão mais modernos, mais rápidos e confiáveis, como Mercurial, Bazaar e, é claro, Git.

1.4 - Controle de versão rápido e confiável com Git

O Git é um sistema de controle de versão que, pela sua estrutura interna, é uma máquina do tempo extremamente rápida e é um robô de integração bem competente.

Foi criado em 2005 por Linus Torvalds, o mesmo criador do Linux, que estava descontente com o BitKeeper, o sistema de controle de versão utilizado no desenvolvimento do kernel do Linux.

Hoje em dia, além do kernel do Linux, a ferramenta é utilizada em diversos outros projetos de código aberto. O Git também é bastante utilizado em empresas em todo o mundo, inclusive no Brasil.

Atualmente, conhecer bem como utilizar o Git é uma habilidade importante para uma carreira bem-sucedida no desenvolvimento de software.

1.5 - Hospedando código no GitHub

Em 2008, foi criado o GitHub, uma aplicação Web que possibilita a hospedagem de repositórios Git, além de servir como uma rede social para programadores.

Diversos projetos de código aberto importantes são hospedados no GitHub como jQuery, Node.js, Ruby On Rails, Jenkins, Spring, JUnit e muitos outros.

1.6 - O processo de escrita desse livro

A utilização do Git não é restrita apenas ao desenvolvimento de software, muitos administradores de rede, por exemplo, utilizam o Git para manter o histórico de evolução de arquivos de configurações em servidores.

Acreditem, até mesmo a escrita desse livro foi feita utilizando o Git!

Não apenas esse, mas todos os livros da editora Casa do Código utilizam o Git como ferramenta de controle de versão, para manter o histórico de evolução dos capítulos. O GitHub também é utilizado para hospedagem dos repositórios dos livros.

Dados do produto

Número de páginas:
204
ISBN:
978-85-66250-53-4
Data publicação:
08/2014

Compartilhe!

Compartilhe no Facebook Compartilhe no Twitter