Descubra o poder do Git: Introdução ao controle de versão - Parte 1

Olá! Aqui começo uma interessante série de artigos relacionados a uma das ferramentas que todo desenvolvedor usa independente de ser frontend, backend, desenvolvedor mobile, etc. Todos nós encontramos uma ferramenta comum para fazer backups do nosso código, colaborar com outros desenvolvedores, por isso seu bom entendimento, conhecimento e uso é crucial para o dia a dia: falamos do Git.

A ideia desses artigos é que obtenhamos informações ordenadas e unificadas revisando temas desde os mais básicos até os mais avançados. Junto com isso, adicionarei minha experiência como desenvolvedor backend.

1) Uma breve história do controle de versão

Vamos começar com um pouco de história. Há alguns anos, no mundo da programação, os desenvolvedores enfrentavam um grande problema ao trabalhar em equipe: o controle de versão. Isso acontecia porque muitas vezes vários programadores trabalhavam no mesmo projeto ao mesmo tempo e precisavam compartilhar seus códigos uns com os outros. No entanto, isso nem sempre foi fácil e muitas vezes surgiram conflitos ao tentar combinar o código de várias pessoas.

Para resolver esse problema, surgiram as primeiras ferramentas de controle de versão, como CVS e Subversion, permitindo que os desenvolvedores trabalhassem juntos e compartilhassem seu código com mais eficiência. No entanto, essas ferramentas iniciais tinham algumas desvantagens importantes:

• Lentidão: Uma das principais razões para sua lentidão era sua arquitetura centralizada. Em um sistema centralizado como o Subversion, todas as alterações são registradas em um servidor central e toda vez que um usuário precisa obter uma cópia atualizada de um arquivo, ele precisa baixá-lo do servidor central. Isso pode ser lento se o arquivo for grande ou se houver muitas alterações feitas desde a última vez que uma cópia do arquivo foi baixada. Além disso, o Subversion usava o protocolo HTTP para transferências de arquivos, o que adicionava sobrecarga adicional às operações de leitura e gravação de arquivos, o que também contribuía para sua lentidão.
  
• Complexidade e dificuldade de uso: O Subversion tinha termos técnicos e específicos que não eram fáceis de entender. Por exemplo, revisar, confirmar e mesclar podem ter significados diferentes nesse contexto. Além disso, exigia uma configuração complicada que poderia ser opressiva para usuários novos ou menos experientes (por exemplo, você precisava configurar um servidor e clientes para usar o Subversion efetivamente). Da mesma forma, ele usava comandos complexos que precisavam ser digitados em uma linha de comando, o que poderia ser confuso para alguns usuários (svn checkout, svn commit e svn merge são alguns dos comandos mais comuns). Por fim, não se integrava facilmente com outras ferramentas de desenvolvimento, dificultando sua incorporação ao fluxo de trabalho de alguns usuários. Se alguém usa um editor de código específico, nem sempre é fácil integrar o Subversion a esse editor.
  
• Dificuldade em versionar projetos de grande escala: Gerenciar um projeto com muitos arquivos grandes e várias ramificações de desenvolvimento era uma dor de cabeça porque seu desempenho diminui significativamente à medida que o tamanho do projeto e o número de desenvolvedores trabalhando nele aumentam.

Um exemplo simples disso pode ser uma equipe de desenvolvimento trabalhando em um projeto de software muito grande com centenas de milhares de linhas de código e várias ramificações de desenvolvimento.

À medida que os desenvolvedores fazem alterações no código e enviam suas modificações para o repositório SVN, o sistema deve acompanhar cada uma dessas alterações e atualizar a versão do código encontrado no repositório central. Com o aumento de alterações e arquivos, o SVN pode se tornar lento e menos eficiente, o que pode afetar o tempo de construção do projeto e o tempo de resposta do sistema.

Então, o Git veio em socorro.

2) O que é Git e por que ele é tão bom?

Simplificando, o Git é uma ferramenta de controle de versão “distribuída” gratuita que permite que os desenvolvedores trabalhem juntos e compartilhem seu código com mais eficiência.

Comparado ao SVN, o Git resolve os problemas de lentidão, dificuldade de usabilidade, configuração complicada, comandos complexos e falta de integração com outras ferramentas de desenvolvimento.

• O Git é mais rápido que o SVN devido à sua arquitetura distribuída. Em vez de ter um único servidor centralizado, cada usuário tem uma cópia completa do repositório em seu próprio dispositivo. Isso permite que os usuários trabalhem sem conexão com a Internet e executem operações mais rápidas em seus próprios dispositivos.
  
• O Git é mais fácil de usar do que o SVN porque possui termos mais intuitivos e claros e não requer configuração complexa. Por exemplo, ao invés de falar sobre revisões e commits, o Git se refere a commits e branches que são mais fáceis de entender. Além disso, o Git possui uma interface gráfica de usuário (GUI) mais simples e comandos que facilitam seu uso.
  
• O Git é mais fácil de configurar do que o SVN porque não requer um servidor centralizado. Em vez disso, os usuários podem compartilhar seu código por meio de repositórios remotos que podem ser hospedados em sites como GitHub, GitLab ou Bitbucket. Isso torna o Git mais fácil de usar para usuários novos e menos experientes.
  
• O Git possui comandos mais simples que podem ser digitados em uma linha de comando. Por exemplo, git clone, git commit e git merge são alguns comandos comuns no Git.
  
• O Git integra-se facilmente com outras ferramentas de desenvolvimento. Por exemplo, muitos editores de código, como Visual Studio Code e Atom, possuem extensões que permitem fácil integração com o Git.
  
• O Git é mais eficiente ao lidar com projetos grandes e complexos porque não diminui a velocidade com o tamanho do projeto e o número de desenvolvedores trabalhando nele. Cada desenvolvedor pode trabalhar em sua própria cópia do repositório e fazer alterações de forma independente. As mudanças são então combinadas usando um processo chamado merge que ajuda a manter a integridade do projeto.

3) A linha de comando

A linha de comando do Git é uma interface de texto que permite interagir com o sistema de controle de versão do Git usando comandos. Embora o Git tenha uma interface gráfica com o usuário, muitas pessoas preferem trabalhar com a linha de comando por vários motivos:

• Eficiência: a linha de comando pode ser mais rápida do que a interface gráfica do usuário para determinadas tarefas, especialmente tarefas repetitivas ou trabalhar com grandes projetos.
  
• Controle: a linha de comando permite maior controle e personalização dos comandos executados, o que pode ser útil para usuários avançados.
  
• Portabilidade: a linha de comando pode ser executada em qualquer sistema operacional que tenha o Git instalado, tornando-o mais portátil que o interface gráfica do usuário.
  
• Consistência: a linha de comando tem uma sintaxe consistente e fluxo de trabalho que não muda entre diferentes versões ou sistemas operacionais.

Embora a linha de comando do Git possa parecer intimidadora para novos usuários, com a prática ela se torna mais fácil e pode ser muito poderosa. Alguns dos comandos mais comuns no Git incluem:

• git init: Inicia um novo repositório Git.

• git add: adiciona um arquivo à área de preparação para ser incluído no próximo commit.
  
• git commit: cria um novo commit contendo as alterações feitas nos arquivos adicionados à área de preparação.

• git push: envia as alterações do repositório local para o repositório remoto.

• git pull: baixa as alterações do repositório remoto e as mescla com as alterações locais.

• git branch: Exibe uma lista de branches no repositório.

• git checkout: altera a ramificação atual do repositório.

Estes são apenas alguns dos comandos disponíveis no Git. Ao longo desta série de artigos vamos aprofundar, bem como explicações detalhadas de como eles são usados.

4) Instalação do Git

Windows

1. Baixe o instalador do Git na página oficial: https://git-scm.com/downloads
2. Uma vez baixado, clique duas vezes no arquivo para abrir o instalador.
3. Uma janela de boas-vindas aparecerá. Clique em Next para continuar.
4. Uma tela de contrato de licença será exibida. Leia os termos e condições e, se concordar, clique em Next.
5. A próxima etapa permitirá que você selecione o local onde deseja instalar o Git. A menos que você tenha um motivo específico para alterá-lo, você pode deixar as configurações padrão e clicar em Next.
6. Na próxima tela, o instalador perguntará quais componentes você deseja instalar. Aqui, você pode deixar todas as opções padrão e clicar em Next.
7. Na próxima tela, o instalador perguntará qual editor de texto você deseja usar para o Git. Novamente, você pode deixar a opção padrão e clicar em Next.
8. Você será perguntado qual terminal de linha de comando deseja usar. Novamente, você pode deixar a opção padrão e clicar em Next.
9. Na próxima tela, o instalador perguntará se você deseja criar atalhos para o Git. Você pode escolher se deseja que os atalhos sejam criados na área de trabalho e/ou no menu Iniciar. Depois de selecionar suas opções, clique em Next.
10. Por fim, você será perguntado se deseja que o Git use o sistema Git Bash. Você pode deixar a opção padrão e clicar em Next.
11. A instalação será iniciada. Esse processo pode levar alguns minutos.
12. Quando a instalação estiver concluída, clique em Finish para sair do instalador.

Mac

1) Abra a App Store no seu Mac.

2) Na barra de pesquisa, digite xcode e pressione Enter.

3) Clique no botão Obter (Get) ao lado do xcode para baixar e instalar a ferramenta.

4) Abra o Terminal no seu Mac. Você pode fazer isso procurando por Terminal no Spotlight ou na pasta Utilitários dentro da pasta Aplicativos.

5) Verifique se as ferramentas de linha de comando do xcode estão instaladas digitando o seguinte comando no Terminal: xcode-select.

6) Instale o Git usando o Homebrew. Se você não tiver o Homebrew instalado no seu Mac, abra o Terminal e digite:

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install.sh)"

Em seguida, siga as instruções para instalar o Homebrew.

7) Depois de instalar o Homebrew, digite o seguinte comando no terminal para instalar o Git:

• brew install git

8) Aguarde a conclusão da instalação. Depois de concluído, verifique se o Git está instalado digitando o seguinte comando no Terminal: git --version.

Com isso, você deve ver a versão do Git que acabou de instalar.

Linux

1) Abra o terminal. Na maioria das distribuições Linux, o terminal está localizado no menu de aplicativos, na pasta de utilitários ou na barra de tarefas.

2) Verifique se o Git já está instalado em seu sistema digitando o seguinte comando no terminal e pressionando enter:

• git --version

Se o Git já estiver instalado, a versão instalada será exibida. Se não estiver instalado, ele mostrará uma mensagem de erro.

3) Se o Git não estiver instalado, use o seguinte comando para instalá-lo:

Em distribuições baseadas no Debian, como o Ubuntu:

• sudo apt-get update | sudo apt-get install git

Em distribuições baseadas em Red Hat, como Fedora e CentOS:

• sudo yum install git

Em distribuições baseadas em SUSE, como openSUSE:

• sudo zypper install git

4) Após a conclusão do processo de instalação, verifique se o Git foi instalado com sucesso digitando o seguinte comando no terminal:

• git --version

Com isso, você deve ver a versão do Git instalada em seu sistema.

5) Configuração do Git pela primeira vez

Após instalar o Git, é importante configurá-lo corretamente para que funcione corretamente em seu sistema. Aqui estão alguns passos a seguir para configurar o Git pela primeira vez:

1) Abra a terminal: A maioria das distribuições do Linux inclui um emulador de terminal que pode ser aberto no menu de aplicativos.

2) Verifique se o Git está instalado: Antes de começar a configurar o Git, verifique se ele está instalado em seu sistema. Para verificar a versão do Git instalada, abra o terminal e digite:

• git --version

Você deve ver a versão do Git instalada em seu sistema.

3) Configure seu nome de usuário e e-mail: Para configurar o Git, é importante configurar seu nome de usuário e endereço de e-mail para que futuras contribuições possam ser atribuídas a você. Para fazer isso, digite os seguintes comandos no terminal, substituindo "seu nome" e "seu e-mail" por suas informações pessoais:

• git config --global user.name "seu nome".
• git config --global user.email "seu e-mail".

4) Definir o editor de texto padrão: O Git usa um editor de texto para exibir mensagens e escrever descrições. O editor padrão do Git é o Vim, que não é muito amigável para novos usuários. Para alterar o editor padrão do Git, use o seguinte comando:

• git config --global core.editor "nome do editor" ("nombre del editor" em espanhol).

Por exemplo, se você quiser usar o Nano como seu editor padrão, digite o seguinte comando:

• git config --global core.editor nano

5) Definir a interface padrão: O Git tem duas interfaces padrão: a linha de comando e a Interface Gráfica do Usuário (GUI). Se você preferir usar a interface de linha de comando, não precisa fazer nada, mas se quiser usar a GUI, precisará instalar um aplicativo que forneça uma GUI para Git. Para definir a interface padrão, use o seguinte comando:

• git config --global core.gui "nome da GUI" ("nombre de la GUI" em espanhol).

Por exemplo, se você deseja usar o GitK como sua GUI padrão, digite o seguinte comando:

• git config --global core.gui gitk

Com essas etapas, você poderá configurar o Git com sucesso em seu sistema. Esses comandos são apenas um exemplo, para que você possa personalizar sua configuração de acordo com suas necessidades.

6) Obter ajuda

Se você precisar de ajuda ao usar o Git, existem três maneiras equivalentes de obter a página de manual completa (manpage) para qualquer comando do Git:

• $ git help <verb>
• $ git <verb> --help
• $ man git-<verb>

Por exemplo, você pode obter ajuda da página de manual para o comando git config executando isto:

• $ git help config

Esses comandos são úteis porque você pode acessá-los de qualquer lugar, mesmo sem conexão com a internet.

Além disso, se você não precisa da ajuda completa da página de manual, mas apenas um lembrete rápido das opções disponíveis para um comando Git, você pode solicitar uma saída de "ajuda" mais concisa com a opção -h, como em:

• $ git add -h

Conclusão

Neste artigo falamos sobre controle de versão, porque ele existe, qual a sua utilidade e ferramentas utilizadas no início. Também são mencionadas as limitações de ferramentas anteriores como o SVN, que incluíam questões de velocidade, complexidade e dificuldade de uso que levaram ao desenvolvimento de ferramentas como o Git.

Por ser gratuito e distribuído com controle de versão que supera as limitações do SVN, o Git é mais rápido, fácil de usar e se integra bem com outras ferramentas de desenvolvimento, além de poder ser instalado em qualquer sistema operacional e aplicar alguns comandos básicos para habilitá-lo em nosso sistema.

Espero que esta primeira parte tenha sido útil para entender os detalhes básicos do Git. A seguir iremos mais longe com esta grande ferramenta. Aí nos vemos!