Controle de versão com Git – Novo treinamento!

- por Sergio Prado

Categorias: Treinamentos Tags: ,

Tão importante quanto escrever um software que funciona é gerenciar o ciclo de vida do código-fonte.

Que mudanças foram introduzidas na versão X do software? Como manter e gerenciar múltiplos releases do código-fonte? Qual a diferença entre as versões A e B? Como sincronizar o código-fonte do desenvolvedor com um servidor para evitar perda de dados? Quem foi o responsável por introduzir a mudança X no código-fonte? Como garantir que múltiplos desenvolvedores trabalhem na mesma base de código-fonte sem problemas de conflito? Como manter múltiplas versões do código e garantir que um bug encontrado em produção seja corrigido em todas elas?

Se você não consegue responder facilmente estas e muitas outras questões inerentes a projetos de software, talvez precise melhorar seu processo de desenvolvimento. E o que pode estar faltando para você é uma ferramenta de controle de versão. Ou a ferramenta de controle de versão mais apropriada para a sua empresa/equipe/projeto.

Sou usuário de ferramentas de controle de versão desde o CVS (argh!). Fiquei um bom tempo no SVN e depois migrei para o Git. E foi um caminho sem volta. O Git tem um design simples e elegante, é extremamente eficiente, perfeito para projetos grandes com equipes distribuídas, mas também se encaixa muito bem em projetos pequenos com equipes menores.

A verdade é que o Git é tão flexível e eficiente que te permite trabalhar de várias formas diferentes. E com o surgimento do GitHub, BitBucket e outros sites de hospedagem e compartilhamento de código, o uso do Git aumentou ainda mais, tornando-se a ferramenta de controle de versão mais popular atualmente.

Durante um bom tempo, eu fui um “usuário Stack Overflow” da ferramenta. Sempre que precisava de algo (desfazer um commit, limpar o index, mudar o HEAD, fazer rebase, resolver conflitos de merge, etc.), fazia algumas buscas no Google que me levavam a uma pergunta no Stack Overflow com a solução, resolvendo o meu problema com um simples Control-C + Control-V. Eu nem me preocupava muito com os detalhes do processo.

Depois de um tempo percebi que, entendendo alguns princípios básicos do funcionamento interno do Git, comandos como reset, pull, fetch, cherry-pick e revert passaram a fazer muito mais sentido, e ficou muito mais fácil entender conceitos como as diversas estratégias de merge existentes (fast-forward, recursive, etc), as diferenças entre merge e rebase, quando utilizar fetch ou pull, dentre muitos outros assuntos que parecem místicos e complicados no Git.

O fato é que hoje em dia é extremamente importante para todo desenvolvedor de software conhecer e saber utilizar o Git, e uma conta no GitHub já faz parte do currículo de todo profissional da área.

É por este motivo que nas últimas semanas estive trabalhando em um novo material, e hoje estou lançando oficialmente o treinamento “Controle de versão com Git”.

Este treinamento é para o iniciante que teve pouco ou nenhum contato com a ferramenta. E também para usuários intermediários e avançados, que conhecem o funcionamento da ferramenta com uma certa profundidade, mas tem muitas dúvidas sobre alguns conceitos e comandos mais avançados como reset, stash, rebasing interativo, estratégias de branching e merging, etc.

O treinamento está bastante completo e cobre os principais recursos do Git. São 2 dias de treinamento (16 horas) divididos em 8 tópicos principais, com 1 exercício por tópico e 441 slides no total!

  1. Introdução às ferramentas de controle de versão e ao Git. Os principais comandos estudados neste tópico são init, add, status, commit, log, diff.
  2. Conceitos básicos do Git. Os principais comandos estudados neste tópico são init, status, add, commit, diff, difftool, mv, rm, log, show.
  3. Trabalhando com branches e tags. Os principais comandos estudados neste tópico são branch, checkout, show-branch, log, merge, rebase, reflog, tag, show.
  4. Explorando o histórico do Git. Os principais comandos estudados neste tópico são log, show, shortlog, diff, grep, blame, bisect.
  5. Reescrevendo o histórico de commits. Os principais comandos estudados neste tópico são commit, rebase, filter-branch, reset, checkout, cherry-pick, revert, clean, stash.
  6. O funcionamento interno do Git. Os principais comandos estudados neste tópico são init, hash-object, cat-file, update-index, ls-files, write-tree, commit-tree, update-ref, symbolic-ref, rev-list, rev-parse, gc.
  7. Gerenciando e trabalhando com repositórios remotos. Os principais comandos estudados neste tópico são clone, remote, ls-remote, branch, checkout, fetch, pull, push, format-patch, send-email, apply, am.
  8. Workflows de desenvolvimento e ferramentas. Os principais comandos estudados neste tópico são checkout, branch, describe, archive, submodule.

Todas as informações, incluindo a agenda completa, estão disponíveis na página oficial do treinamento no site da Embedded Labworks. E como sempre faço em todos os meus treinamentos, os slides também estão disponíveis sob licença Creative Commons BY-SA 3.0.

Quem quiser levar este treinamento para a sua empresa, é só entrar em contato.

Por fim, estou abrindo uma turma experimental deste treinamento, com o valor promocional de R$180,00 para pagamento à vista no boleto ou depósito bancário, ou R$200,00 para pagamento no cartão de crédito em até 2 vezes. É realmente um valor promocional, apenas para cobrir os custos de locação da sala, infraestrutura e coffee-break. Em troca, você será minha cobaia e me ajudará a testar o material, o formato e o conteúdo do treinamento. :-)

Esta turma vai acontecer em São Paulo/SP, nos dias 31/05 e 01/06, em período integral, das 08:30 às 17:30.

Se você estiver interessado, é só se inscrever no site da Embedded Labworks. Mas corra que as vagas são limitadas!

Espero você lá!

Um abraço,

Sergio Prado

  • Rodrigo Arnhold

    Sérgio seus treinamentos são muito bons. Deveria de oferecer a oportunidade de realizar eles online. Pois normalmente os treinamentos mais interessantes são em São Paulo, e isso acaba dificultando a aquisição deles.

    • Olá Rodrigo!

      Muito obrigado pelo feedback.

      Tenha esta mesma visão de que poderia alcançar muito mais pessoas fazendo os treinamentos em uma plataforma de ensino à distância.

      Nos últimos meses tenho avaliado esta possibilidade, mas é um modelo de negócios bem diferente do modelo que utilizo atualmente.

      Teria um impacto também no material dos treinamentos. O ensino à distância exige uma didática e formato de material um pouco diferente.

      De qualquer forma, estou analisando esta possibilidade, e qualquer novidade publicarei aqui no blog.

      Um abraço!

      • Tiago Henrique Macedo

        Sérgio, eu também gostaria de participar, além do tema ser do meu interesse, todos os treinamentos que fiz com você foram excelentes. No meu caso, o que dificulta é que eles ocorrem durante a semana. Já pensou em abrir algumas turmas para treinamento aos finais de semana? Imagino que outros colegas tenham interesse em se qualificar por iniciativa própria.

        • Olá Tiago!

          No passado eu até trabalhava com treinamentos aos sábados, mas tinha certa dificuldade para fechar as turmas. Mas já faz um tempo, e talvez valha a pena tentar novamente. Sua sugestão está anotada.

          Um abraço!

  • Rafael Campos Las Heras

    Ótima iniciativa Sergio!
    Excelente material. O capítulo sobre plumbing vs porcelain é excelente.

    Ainda bem que não teve que sofrer outros sistemas de controle de versões como Visual SourceSafe ou Rational Clear Case ;)

    Gostei da menção ao git submodules, agora senti falta de git subtree [1] e git
    subrepo [2] que suprem algumas deficiências do git submoules (especialmente a perda de modificações no submodule quando é feito um update do modulo ;) ). Também pode ser interessante falar de repo[3] e jiri [4]?

    E também seria legal adicionar algumas outras ferramentas que ajudam na qualidade do código (poer exemplo CodeReview com Gerrit ou pull request no Bitbucket, Github, Gitlab, etc.). Mais este assunto pode ser matéria para um outro curso.

    Abraços

    [1] https://github.com/apenwarr/git-subtree
    [2] https://github.com/ingydotnet/git-subrepo
    [3] https://gerrit.googlesource.com/git-repo
    [4] https://fuchsia.googlesource.com/jiri/

    • Olá Rafael!

      Muito obrigado por ler o material e me passar um feedback!

      Realmente git submodule foi uma “adição de última hora” ao material, e talvez eu devesse ter uma seção separada de slides apenas sobre o gerenciamento de projetos com múltiplos repositórios dependentes.

      Ficou faltando também um material mais detalhado sobre estes sites de colaboração e compartilhamento de código online como o GitHub e o BitBucket.

      A minha única preocupação é o tempo, talvez devesse estender o treinamento a 3 dias para cobrir tudo isso. Quem sabe na próxima revisão do material.

      Um abraço!

Navegue
Creative Commons Este trabalho de Sergio Prado é licenciado pelo
Creative Commons BY-NC-SA 3.0.