Princípios relacionados ao controle de versão de softwares

Controle de Versão

O controle de versão é a prática de rastrear e gerenciar as alterações em um código de software. Os sistemas de controle de versão são ferramentas de software que ajudam as equipes a gerenciar as alterações ao código-fonte ao longo do tempo. Eles são ainda mais úteis para as equipes de DevOps, pois as auxiliam a reduzir o tempo de desenvolvimento e aumentar as implementações bem-sucedidas.

O software de controle de versão mantém registro de todas as modificações no código em um tipo especial de banco de dados. Se um erro for cometido, os desenvolvedores podem voltar no tempo e comparar versões anteriores do código para ajudar a corrigir o erro enquanto diminuem interrupções para todos os membros da equipe.

Mas por que o controle de versão é importante?

Há muitas coisas que podem levar tempo no desenvolvimento de novas aplicações; reproduzir bugs, aprender novas ferramentas e adicionar novos recursos ou conteúdo são apenas alguns exemplos. À medida que as demandas dos usuários se expandem, o controle de versão ajuda as equipes a trabalharem em conjunto, poupando tempo.

Benefícios do controle de versão

Criar fluxos de trabalho

Os fluxos de trabalho de controle de versão impedem o caos de todos que usam seu próprio processo de desenvolvimento com ferramentas diferentes e incompatíveis. Os sistemas de controle de versão fornecem imposição de processo e permissões para que todos permaneçam na mesma página.

Trabalhar com versões

Cada versão tem uma descrição do que as alterações fazem, como corrigir um bug ou adicionar um recurso. Essas descrições ajudam a equipe a seguir as alterações no código por versão, em vez de por alterações de arquivo individuais. O código armazenado em versões pode ser exibido e restaurado a partir do controle de versão a qualquer momento, conforme necessário. As versões facilitam a base de novo trabalho de qualquer versão do código.

Codificar juntos

O controle de versão sincroniza suas publicações e garante que as alterações não entrem em conflito com as alterações de outras pessoas. A equipe depende do controle de versão para ajudar a resolver e prevenir conflitos, mesmo quando as pessoas fazem alterações ao mesmo tempo.

Manter um histórico

O controle de versão mantém um histórico de alterações à medida que a equipe salva novas versões de código. Os membros da equipe podem examinar o histórico para descobrir quem, o porquê e quando as alterações foram feitas. O histórico dá às equipes a confiança para experimentar, pois é fácil reverter para uma versão anterior a qualquer momento. O histórico permite que qualquer pessoa trabalhe em base de qualquer versão do código, como corrigir um bug em uma versão anterior.

Automatizar tarefas

Os recursos de automação de controle de versão economizam tempo e geram resultados consistentes. Automatizar testes, análise de código e implantação quando novas versões forem salvas no controle de versão são alguns destes exemplos.

Então…

Embora seja possível desenvolver software sem usar nenhum controle de versão, fazer isso submete o projeto a um alto risco que nenhuma equipe profissional seria aconselhada a aceitar. Então, a pergunta não é se a gente deve usar um controle de versão, mas qual sistema de controle de versão utilizar.

Para solucionarmos esse possível problema, o mercado nos apresenta diversas ferramentas que podem ser utilizadas com essa finalidade (cvs, subversion, tfs, git, mercurial, dentre outras). Para descobrir qual é a melhor de acordo com as necessidades e demandas da sua empresa é importante conhecer cada um delas, assim como as vantagens e desvantagens apresentadas. Portanto não entrarei em detalhes em cada uma delas, mas apresentarei o sistema de controle de versão mais utilizado no mundo, o git.

GIT

De longe, o sistema de controle de versão moderno mais usado no mundo hoje é o Git. O Git é um projeto de código aberto maduro e com manutenção ativa desenvolvido em 2005 por Linus Torvalds, o famoso criador do kernel do sistema operacional Linux. Um número impressionante de projetos de software dependem do Git para controle de versão, incluindo projetos comerciais e de código-fonte aberto. Os desenvolvedores que trabalharam com o Git estão bem representados no desenvolvimento de software disponíveis e funcionam bem em uma ampla variedade de sistemas operacionais e IDEs (Ambientes de Desenvolvimento Integrado).

Tendo uma arquitetura distribuída, o Git é um exemplo de DVCS (portanto, Sistema de Controle de Versão Distribuído). Em vez de ter apenas um único local para o histórico completo da versão do software, como é comum em sistemas de controle de versão outrora populares como CVS ou Subversion (também conhecido como SVN), no Git, a cópia de trabalho de todo desenvolvedor do código também é um repositório que pode conter o histórico completo de todas as alterações.

A flexibilidade e a popularidade do Git fazem dele uma ótima opção para qualquer equipe. Muitos desenvolvedores e universitários já sabem como usar o Git. A comunidade de usuários do Git criou recursos para treinar desenvolvedores e a popularidade do Git facilita a obtenção de ajuda quando necessário. Quase todos os ambientes de desenvolvimento têm suporte do Git e ferramentas de linha de comando git implementadas em todos os principais sistemas operacionais.

Noções básicas do Git

Sempre que o trabalho é salvo, o Git cria uma confirmação. Uma confirmação é um instantâneo de todos os arquivos em um momento. Se um arquivo não tiver sido alterado de uma confirmação para a próxima, o Git usará o arquivo armazenado anteriormente. Esse design difere de outros sistemas que armazenam uma versão inicial de um arquivo e mantêm um registro de deltas ao longo do tempo.

Confirma a criação de links para outras confirmações, formando um grafo do histórico de desenvolvimento. É possível reverter o código para uma confirmação anterior, inspecionar como os arquivos foram alterados de uma confirmação para outra e examinar informações como, onde e quando as alterações foram feitas. As confirmações são identificadas no Git por um hash criptográfico exclusivo do conteúdo da confirmação. Como tudo é hash, é impossível fazer alterações, perder informações ou corrompê-las sem que o Git a detecte.

Branches

Cada desenvolvedor salva alterações em seu próprio repositório de código local. Como resultado, pode haver muitas alterações diferentes com base na mesma confirmação. O Git fornece ferramentas para isolar as alterações e depois mesclá-las novamente. Os branches, que são ponteiros leves para trabalhar em andamento, gerenciam essa separação. Depois que o trabalho criado em um branch é concluído, ele pode ser mesclado novamente no branch principal (ou no tronco) da equipe.

Arquivos e confirmações

Os arquivos no Git estão em um dos três estados: modificados, preparados ou confirmados. Quando um arquivo é modificado pela primeira vez, as alterações só existem no diretório de trabalho. Eles ainda não fazem parte de uma confirmação ou do histórico de desenvolvimento. O desenvolvedor deve preparar os arquivos alterados para serem incluídos na confirmação. A área de preparo contém todas as alterações a serem incluídas na próxima confirmação. Depois que o desenvolvedor estiver satisfeito com os arquivos em etapas, os arquivos serão empacotados como uma confirmação com uma mensagem que descreve o que mudou. Essa confirmação se torna parte do histórico de desenvolvimento.

O preparo permite que os desenvolvedores escolham quais alterações de arquivo salvar em uma confirmação para dividir grandes alterações em uma série de confirmações menores. Ao reduzir o escopo de confirmações, é mais fácil examinar o histórico de confirmação para encontrar alterações de arquivo específicas.

Vamos a prática…

Instalando o GIT

GIT para Mac

Há várias maneiras de instalar o Git em um Mac. Na verdade, se você instalou o Xcode (ou suas ferramentas de linha de comando), o Git pode já estar instalado. Para saber, abra um terminal e digite git — version.

Se tiver instalado o Homebrew para gerenciar pacotes no OS X, siga estas instruções para instalar o Git:

$ brew install git

Verifique se a instalação foi bem-sucedida digitando a git — version:

$ git — version

Configure o nome de usuário e e-mail do Git usando os comandos a seguir, substituindo o nome de Emma pelo seu próprio. Essas informações vão ser associadas a quaisquer commits que você criar:

$ git config — global user.name “Qualquer Nome”

$ git config — global user.email “seu@email.com”

GIT para Windows

Baixe o instalador mais recente do Git for Windows.

Quando você tiver iniciado o instalador com sucesso, vai ver a tela do assistente de configuração do Git. Siga os avisos Next e Finish para concluir a instalação. As opções padrão são bastante sensíveis para a maioria dos usuários.

Abra um prompt de comando (ou Git Bash se durante a instalação você optou por não usar o Git do Prompt de Comando do Windows).

Execute os comandos a seguir para configurar o nome do usuário e e-mail do Git, substituindo o nome Emma pelo seu próprio. Essas informações vão ser associadas a quaisquer commits que você criar:

$ git config — global user.name “Qualquer nome” $ git config — global user.email “seu@email.com”

GitHub

De longe, o principal host do mundo para projetos Git é o GitHub. O GitHub fornece muito mais do que apenas hospedagem do Git. O GitHub tem recursos que abrangem todo o processo de DevOps, incluindo um marketplace de produtos e serviços de parceiros.

Configurar um repositório GIT

Um repositório Git, ou repositório, é uma pasta na qual o Git acompanha as alterações. Pode haver qualquer número de repositórios em um computador, cada um armazenado em sua própria pasta. Cada repositório Git em um sistema é independente, portanto, as alterações salvas em um repositório Git não afetam o conteúdo de outro.

Um repositório Git contém todas as versões de cada arquivo salvo no repositório. Isso é diferente de outros sistemas de controle de versão que armazenam apenas as diferenças entre arquivos. O Git armazena as versões do arquivo em uma pasta .git oculta ao lado de outras informações necessárias para gerenciar o código. O Git salva esses arquivos com muita eficiência, portanto, ter um grande número de versões não significa que ele usa muito espaço em disco. Armazenar cada versão de um arquivo ajuda o Código de mesclagem do Git melhor e facilita o trabalho com várias versões de código.

Os desenvolvedores trabalham com o Git por meio de comandos emitidos enquanto trabalham em um repositório local no computador. Mesmo ao compartilhar código ou receber atualizações da equipe, ele é feito a partir de comandos que atualizam o repositório local. Esse design com foco local é o que torna o Git um sistema de controle de versão distribuída. Cada repositório é autocontido e o proprietário do repositório é responsável por mantê-lo atualizado com as alterações de outras pessoas.

A maioria das equipes usa um repositório central hospedado em um servidor que todos podem acessar para coordenar suas alterações.

Criar um novo repositório Git

Você tem duas opções para criar um repositório Git. Você pode criar um a partir do código em uma pasta em um computador ou clonar um de um repositório existente. Se estiver trabalhando com o código que está apenas no computador local, crie um repositório local usando o código nessa pasta. Mas, na maioria das vezes, o código já é compartilhado em um repositório Git, portanto, clonar o repositório existente no computador local é a maneira recomendada de ir.

Criar um novo repositório a partir do código existente

Use o git init comando para criar um novo repositório de uma pasta existente no computador. Na linha de comando, navegue até a pasta raiz que contém o código e execute:

git init

para criar o repositório. Em seguida, adicione todos os arquivos na pasta à primeira confirmação usando os seguintes comandos:

git add — all

git commit -m “Initial commit”

Clonar um repositório existente

Para obter uma cópia completa do repositório de outro usuário, use git clone desta forma:

$ git clone https://github.com/USERNAME/REPOSITORY.git

Crie Branches no GitHub

Ao criar branches, ou ramificações, você gera versões diferentes de um repositório. Quando você modifica o projeto nas branches de recursos, um desenvolvedor pode ver como isso vai afetar o projeto principal na hora que tudo for integrado.

Vá para o seu novo repositório. Clique no botão main (principal) e insira o nome. Clique em Create branch (criar branch).

Agora você criou um novo branch de recurso que é idêntico ao branch mestre. Você pode começar a fazer mudanças livremente sem afetar o projeto principal.

Como Funcionam Commits no GitHub

Os Commits são como as mudanças salvas no GitHub são chamadas. Cada vez que você muda o arquivo do branch de recurso, você terá que executar um Commit para mantê-lo.

Acesse a branch de recurso ao clicar em main e selecionar no menu suspenso a sua ramificação recém-criada.

Para editar click no “ícone de lápis” e comece a modificar o arquivo. Assim que estiver terminado, escreva uma descrição curta sobre quais mudanças foram feitas. Clique em Commit Changes (confirmar alterações).

Crie Pull Requests no GitHub

Para propor as mudanças que você acabou de fazer para outros desenvolvedores trabalhando no mesmo projeto, você deve criar um pull request. São eles que fazem ser tão fácil de trabalhar junto em projetos, já que eles são a principal ferramenta de colaboração no GitHub.

Pull Requests permitem que você veja as diferenças entre o projeto original e o seu branch de recurso. É assim que você pede para os seus pares revisá-las. Se os outros desenvolvedores aprovarem as modificações, eles podem executar um merge pull request (solicitação de mesclagem). Isso irá aplicar as mudanças para o projeto principal.

GitHub e a linha de comando…

Comandos básicos do Git

Para usar o Git, os desenvolvedores usam comandos específicos para copiar, criar, alterar e combinar código. Esses comandos podem ser executados diretamente na linha de comando ou usando um aplicativo como GitHub Desktop. Aqui estão alguns comandos comuns para usar o Git:

1. git init inicializa um novo repositório Git e começa a acompanhar um diretório existente. Ele adiciona uma subpasta oculta dentro do diretório existente que contém a estrutura de dados interna necessária para o controle de versão.

2. git clone cria uma cópia local de um projeto que já existe remotamente. O clone inclui todos os arquivos, histórico e branches do projeto.

3. git add prepara uma alteração. O Git controla as alterações na base de código de um desenvolvedor, mas é necessário testar e tirar um instantâneo das alterações para incluí-las no histórico do projeto. Este comando executa o teste, a primeira parte do processo de duas etapas. Todas as mudanças que são testadas irão tornar-se parte do próximo instantâneo e parte do histórico do projeto. O teste e o commit separados dão aos desenvolvedores total controle sobre o histórico do seu projeto sem alterar como eles codificam e funcionam.

4. git commit salva o instantâneo no histórico do projeto e conclui o processo de controle de alterações. Em suma, um commit funciona como tirar uma foto. Qualquer item que tenha sido preparado com git add passará a fazer parte do instantâneo com git commit.

5. git status mostra o status das alterações como não controladas, modificadas ou preparadas.

6. git branch mostra os branches que estão sendo trabalhados localmente.

7. git merge mescla as linhas de desenvolvimento. De modo geral, esse comando é usado para combinar alterações feitas em dois branches distintos. Por exemplo, um desenvolvedor faria merge quando quisesse combinar alterações de um branch de recurso no branch principal para implantação.

8. git pull atualiza a linha de desenvolvimento local com atualizações do equivalente remoto. Os desenvolvedores usam este comando se um colega fez commits em um branch remoto, e eles gostaria de refletir essas alterações no seu ambiente local.

9. git push atualiza o repositório remoto com todos os commits feitos localmente em um branch.

Conclusão

Ao longo do artigo, vimos o quão importante é mantermos um sistema atualizado e coeso, seguindo para isto padrões de versionamento de software.

Este padrão nos permite gerenciar eficientemente alterações e possíveis problemas que possam surgir no decorrer dos projetos e para isto, podemos utilizar poderosas ferramentas que nos auxiliam a publicar, manter e controlar todo o fluxo de features, correção de bugs, alterações que irão demandar nosso projeto.

Aqui foi apresentado a mais utilizada no mundo, sendo um software gratuito e que está em constante evolução de desenvolvimento.

Referências

https://docs.github.com/pt/get-started/quickstart/hello-world

https://learn.microsoft.com/pt-br/devops/develop/developing-modern-software-with-devops

https://www.atlassian.com/br/git/tutorials/learn-git-with-bitbucket-cloud