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