Saiba como utilizar a estrutura de versionamento do Git e a busca binária para encontrar o commit que introduz um bug.

Por vezes, mesmo sendo bastante cuidadosos, bugs ou outros comportamentos inesperados podem acabar aparecendo no projeto e nem sempre são detectados imediatamente. Isso pode dificultar o trabalho de encontrar e solucionar esses problemas. O Git Bisect é uma ferramenta do Git que pode ajudá-lo a encontrar o commit exato onde o problema começou, reduzindo a quantidade de código que você precisa analisar e tornando o processo de solução do problema menos complicado.

Antes de começarmos…

Para podermos tirar vantagem do Git Bisect, precisamos ter algum conhecimento e nosso projeto deve estar sendo desenvolvido com o Git. Se você ainda não sabe o que é o Git ou ainda não o utiliza em seus projetos, confira este artigo que vai te dar as informações e motivações necessárias para começar!

O que é o Git Bisect?

O Git Bisect é um comando do Git que nos permite utilizar sua estrutura de versionamento para procurar e encontrar a raiz de um determinado comportamento.

Este comportamento não precisa, necessariamente, ser um bug, mas, por ser o caso mais comum e para facilitar a comunicação no restante deste artigo, vamos utilizar esta nomenclatura.

Este comando utiliza um algoritmo de busca binária para percorrer os commits de um dado intervalo de forma a encontrar um commit específico de forma rápida e eficiente.

Explicando resumidamente, para utilizar o Git Bisect, você deve fornecer ao comando dois pontos de partida: o identificador de um “commit bom” e o identificador de um “commit ruim”. A partir disso, o Git sabe o intervalo onde o bug foi introduzido e, com a sua ajuda, vai buscar nos commits deste intervalo até identificar o primeiro “commit ruim”.

Por ser uma ferramenta do próprio Git, você pode tirar proveito do Git Bisect independente da linguagem de programação, das tecnologias e frameworks, e mesmo da plataforma de Git que você usar para o seu projeto. Se o versionamento for feito em Git, você pode utilizar o Git Bisect para ajudar.

Qual é a vantagem de se utilizar Git Bisect

Bugs são um problema inevitável quando se trata de desenvolvimento de software. Por mais cuidadosa que a equipa seja e que tome todas as precauções possíveis, como code review regular e que todas as features passem por controlo de qualidade, alguns pequenos problemas sempre acabam por aparecer.

E nem sempre esses problemas são detectados de imediato; às vezes, ficam escondidos em uma feature pouco usada ou em um caso de uso muito específico, e algum tempo pode se passar até que alguém se dê conta deles. Mesmo depois de encontrarmos um bug, sua solução e sua origem nem sempre são óbvias. Pode ser bastante difícil encontrar a causa de um bug, principalmente nesses casos onde ele não foi descoberto de imediato e não sabemos exatamente qual mudança pode ter causado o problema.

É aqui que o Git Bisect pode nos ajudar. Desde que tenhamos (ou seja possível encontrar) um ponto no passado, um commit anterior onde o bug não acontecia, podemos utilizar este comando e seu algoritmo de busca binária para encontrar exatamente o commit que introduziu o bug. Uma vez que sabemos o commit exato onde o problema começou, temos um volume muito menor de código para investigar. Em vez de olhar para todo o código de todo o projeto, temos um número finito de alterações que podem ter originado o bug. Assim, a tarefa de identificar e corrigir o bug torna-se muito menos árdua.

Como funciona o Git Bisect

Como mencionado anteriormente, o Git Bisect utiliza um algoritmo de busca binária para encontrar o commit responsável pela introdução de um bug.

Quando iniciamos o comando de bisect o git irá nos pedir por uma referência a um “commit bom” e a um “commit ruim”. Chamamos de “ruim” um commit que apresente o bug e de “bom” um commit onde o projeto se comporte como esperado. Dado estes dois pontos de partida o git fará checkout para um commit exactamente no meio do intervalo entre os dois indicados inicialmente, neste ponto temos de testar nosso código e ver se o bug ainda acontece e indicar ao git se este commit de agora é “bom” ou “ruim”. 

A seguir é feito um novo checkout ao commit que estiver exatamente no meio deste novo intervalo e o processo se repete, até encontrarmos o primeiro commit que começa a apresentar o bug. 

As imagens acima exemplificam como funcionam as iterações do Git Bisect, tendo como ponto de partida um “commit bom” e um “commit ruim” vamos reduzindo o intervalo possível de origem do problema, mas sem ter de checar os commits no intervalo individualmente.

Como Utilizar o Git Bisect

Serão feitos diversos checkouts durante o processo de bisect. Por isso, antes de iniciar, recomendo que faça stash ou commit de qualquer alteração que tenha no diretório de trabalho. Se quiser testar o comando, tenho um repositório simples que você pode clonar e utilizar como cobaia. É o mesmo utilizado nas imagens acima e, apesar de ser bastante simples, pode te ajudar a compreender melhor o funcionamento do bisect.

Dito tudo isto, podemos finalmente começar o bisect com o comando:

• git bisect start

E então temos de fornecer os identificadores dos commits de ponto de partida, ou seja, um “commit bom”, em inglês good e um “commit ruim”, em inglês, bad.

• git bisect bad BAD-COMMIT-IDENTIFIER
• git bisect good GOOD-COMMIT-IDENTIFIER
  

Um identificador de commit é, como o nome sugere, algo que torna possível identificar um commit específico. Normalmente utilizamos o hash (ou ID) de cada commit, mas também podemos usar uma tag. Se o commit que desejas marcar como good ou bad for o commit onde estás “checked out” podes omitir o identificador.

Com os dois commits iniciais o git bisect já começa a funcionar e irá fazer checkout para o commit no meio do intervalo entre os dois. Neste ponto, testamos o código e identificamos o commit atual como good ou bad com o comando:

• git bisect good 

ou

• git bisect bad
  
  

A partir daqui, o processo continuará da forma que já expliquei. Cada vez que você indica um commit como good ou bad, um novo intervalo, menor que o anterior, é determinado, e é feito um checkout para o commit no meio deste intervalo. O processo então se repete, identificando o novo commit como good ou bad até que o primeiro commit bad seja encontrado.

Sabendo qual é o commit onde o bug aparece pela primeira vez, você pode avaliar apenas as mudanças introduzidas neste commit para encontrar a causa do problema.

Se quiser saber mais sobre o comando Git Bisect recomendo ler a sua documentação oficial.

Boa Caçada aos Bugs com o Git Bisect

Confesso que, muito provavelmente, você não irá utilizar o Git Bisect todos os dias, mas acredito ser uma boa ferramenta para termos no nosso “cinto de utilidades”. Posso dizer que ela já me ajudou muito em diversas ocasiões, principalmente lidando com bases de código complexas onde diversas pessoas trabalham simultaneamente modificando as mesmas funcionalidades e ficheiros. Espero que da próxima vez que você se deparar com um daqueles bugs complicados, que ninguém parece saber ao certo de onde vem, você se lembre deste artigo e que o Git Bisect consiga te ajudar a restringir a quantidade de código que tem de ser verificado e assim chegar à raiz do problema de forma mais rápida, eficiente e menos dolorosa.