Commits Atômicos: O que são?

Uma prática que desempenha um papel crucial no desenvolvimento de software é o versionamento. Sem o versionamento, seria muito mais complexo fazer o rastreamento de alterações, reverter mudanças indesejadas, implementar novas funcionalidades e trabalhar em equipe.

Nesse contexto, surge a necessidade de não apenas adotar boas práticas na escrita do código, mas também implementar boas práticas no versionamento. Dessa forma, podemos abrir espaço para o desenvolvimento de Commits Atômicos, aplicando conceitos semelhantes aos padrões de design na escrita de código, como o Princípio da Responsabilidade Única, em que cada unidade de código é responsável por uma única tarefa.

Boas práticas são essenciais

Os repositórios de controle de versão (como aqueles criados no GitHub ou GitLab) possuem capacidades que, quando usadas de maneira responsável, podem economizar um tempo valioso no desenvolvimento. Ao enviar um commit, estamos registrando uma parte da história do repositório, que é armazenada cuidadosamente com informações importantes, como o autor, o momento do envio, as alterações realizadas, a mensagem atribuída a essa alteração e um identificador único para o commit, entre outras informações.

Com a consciência de que todas essas informações são registradas em um commit, podemos começar a praticar o desenvolvimento de commits atômicos, que podem ser descritos como unidades lógicas e independentes que representam de forma coesa uma mudança feita no repositório.

No desenvolvimento de commits atômicos, cada commit é considerado completo e autônomo. Em outras palavras, cada commit é responsável por uma única alteração e, idealmente, representa a alteração completa. É importante ressaltar que o desenvolvimento de commits atômicos não se trata de um conjunto de regras rígidas e inflexíveis, mas sim de uma prática que pode ser aprimorada de acordo com o contexto de cada equipe e projeto.

Exemplo prático: Implementação de função de conversão de moedas.

Utilizando a CLI (Interface de Linha de Comando) para criação de commits atômicos

Para exemplificar a criação dos commits atômicos, digamos que temos o seguinte problema a ser resolvido em Python: implementar e testar uma função que converte um valor em Dólar para um valor em Real, recebendo como parâmetros o valor em Dólar a ser convertido e a cotação do Dólar no dia. Neste exemplo, consideramos que já existe um repositório git inicializado.

Podemos iniciar criando um arquivo conversor.py vazio (neste caso, estou utilizando o uma distribuição Linux como sistema operacional e o comando para a criação de um arquivo que vou utilizar será touch <nome_do_arquivo>, mas existem outras formas de fazê-lo de acordo com cada sistema operacional) e adicionando ele ao repositório utilizando o comando git add conversor.py, escrevendo a uma mensagem indicando a criação desse arquivo utilizando o comando git commit -m ‘<mensagem>’ e substituindo <mensagem> pela nossa mensagem.

Observação: feat na mensagem do commit indica que uma nova funcionalidade foi introduzida com as mudanças.

Podemos começar escrevendo o esboço do que será implementado:

O comando git add -p (ou git add –patch) pode ser muito útil no desenvolvimento de commits atômicos, pois ele permite revisar e selecionar partes específicas das alterações que serão posteriormente incluídas no commit.

Nesse primeiro commit, queremos colocar apenas as 2 primeiras linhas, que criam a função que utilizaremos. Se utilizássemos o comando git add conversor.py ou git add ., estaríamos adicionando o arquivo inteiro, e não é o que queremos, então, no terminal, digitamos o comando git add -p:

Esse comando nos dá algumas opções. Para saber o que cada uma delas significa, podemos digitar ?:

Conforme as opções nos mostram, podemos editar manualmente este trecho digitando `e`, e será aberto o editor de texto do git no terminal:

Neste caso, como queremos adicionar apenas as 2 primeiras linhas, podemos deletar as linhas restantes.

Após salvar, podemos utilizar o comando git status -v para ver o resultado:

Como podemos verificar, foram adicionadas apenas as 2 primeiras linhas. Agora podemos criar esse novo commit com uma mensagem, utilizando novamente o comando git commit -m ‘<mensagem>’ e escrevendo nossa mensagem.

Como o nosso próximo commit vai adicionar todo o restante do arquivo (que corresponde à função test_converter_dolar_em_real, podemos simplesmente adicionar todas as alterações no arquivo conversor.py com o comando git add conversor.py e em seguida criar uma mensagem para o nosso próximo commit.

Agora podemos ir para a implementação da função converter_dolar_em_real. A implementação é simplesmente a multiplicação do valor em Dólar para a cotação do Dólar em Real. Ao implementarmos a função, podemos notar que pode ser interessante à nossa função se adicionássemos type hints (dicas de tipo) para as nossas variáveis e para o que a função irá retornar.

Utilizando o VSCode para a criação de commits atômicos

As IDEs que utilizamos para escrever nossos códigos geralmente também estão preparadas para suportar os recursos de versionamento. Neste exemplo, estarei usando o Visual Studio Code para mostrar como realizar os mesmos passos com a ajuda da IDE.

Como fizemos 2 alterações independentes, sendo uma para adicionar os type hints e a outra para implementar a função, faremos 2 commits, um para cada alteração.

Na barra direita, temos um ícone marcado com um número “1”, que corresponde à quantidade de arquivos alterados. Se clicarmos nesse ícone, veremos uma lista desses arquivos alterados.

Nessa aba, se clicarmos no arquivo conversor.py, poderemos ver as alterações feitas nele.

Podemos agora selecionar a linha que desejamos adicionar as alterações e clicar com o botão direito do mouse.

Como foi selecionada apenas a primeira linha, selecionamos a opção Stage Selected Ranges. Se observarmos, após clicar nessa opção, na tela é mostrado que ainda temos a alteração da segunda linha para fazer. Mas antes iremos criar um commit para a alteração da primeira linha, escrevendo no campo de texto à direita e depois clicaremos no botão Commit.

Observação: Utilizamos refactor para indicar que a alteração representa uma refatoração de código que não adiciona nenhuma funcionalidade e nem corrige nenhum bug.

Feito isso, o último commit que precisamos é o da implementação da funcionalidade, que fizemos na segunda linha. Para isso, podemos simplesmente clicar no botão + que aparece nas opções ao lado do nome do arquivo.

Escrevemos então nossa mensagem para o último commit e clicamos novamente no botão Commit.

Conclusão e Resultados

Ao seguirmos esses passos, criamos commits atômicos que realizam uma única alteração por commit, o que nos auxiliará na clareza, legibilidade, rastreabilidade, reversibilidade, implementações incrementais, entre outros benefícios.

Podemos observar o histórico de tudo o que foi feito utilizando o comando git log:

Com essas informações, podemos consultar, rastrear e reverter qualquer alteração feita. Todos esses processos se tornam muito mais eficientes quando utilizamos commits atômicos, além de termos uma história limpa e incremental no nosso repositório.

Espero que esse artigo seja útil para a sua jornada!