GIT: Mas que coisa é esta ?

Introdução

Neste artigo vamos fazer algo um pouco diferente. Irei dar uma pequena pausa na sequência sobre o replay / simulador. Aqui mostrarei uma ferramenta, que se você desconhece, precisa conhecer. Pois ela irá de fato agilizar muito, as suas tarefas como programador.

Aqui o foco será para pessoas que estão iniciando, mas principalmente para os aspirantes a ser tornar um profissional de qualidade. Infelizmente, a ferramenta que mostrarei, não é muito simples de usar no Windows 11, quanto no Windows 10. Então, a preferência no uso, pelo menos no momento que escrevo este artigo, caso você esteja usando o Windows. É fazer o uso da mesma no Windows 10.

A ferramenta é o GIT. Apesar de ser originalmente pensada para LINUX. Esta ferramenta se mostra muito boa e perfeita para quem deseja programar e desenvolver novas aplicações. Porém até o momento, o editor do MQL5, não se integra diretamente a ela. Mas isto não impede de maneira alguma que você possa vim a fazer uso desta ferramenta. No entanto, existem alguns passos que são necessários, antes que você realmente possa tirar algum proveito no seu uso.

Se você já conhece GIT ou trabalha com ele. Este artigo não adicionará nada em seu conhecimento, talvez sirva somente como curiosidade. Porém se você não conhece e vive criando código. Mais hora ou menos hora, acabará fazendo algo, que lhe fará desanimar em continuar a desenvolver uma dada aplicação. Isto por que, durante a edição do código, você sem perceber acabou adicionando uma falha, que só foi notada vários dias ou semanas depois. Acredite, este tipo de coisa é muito mais comum do que possa parecer. Mas o GIT nos ajuda a evitar isto.

GIT que negócio é este ?

GIT é um programa, ou como gosto de chamar, ferramenta. Que nos permite monitorar e catalogar, de forma simples e bastante eficiente, versões de uma aplicação que estamos desenvolvendo. Isto daqui, não será de fato um tutorial, e nem pretendo fazer tal coisa. Mesmo por que, existe uma enormidade de tutoriais sobre o assunto. Mas na grande parte das vezes, tais tutoriais, são voltados para editores que se integram nativamente ao GIT. Como no caso do Visual Studio. Como o MetaEditor não faz isto, precisamos fazer alguns ajustes para que possamos trabalhar adequadamente com o GIT junto com o MQL5.

Uma vez que tais ajustes tenham sido feitos. Você poderá utilizar qualquer tutorial sobre GIT, para se aprofundar ainda mais. Este artigo, deveria ter sido feito antes. Mas não imaginava que existia tanta gente, começando e aspirando se tornar profissional. Tais pessoas, tem muitas dificuldades em se aprimorar, já que desconhecem, meios ou formas de pegar uma aplicação e a modificar, aprendendo com isto. Mas o principal, não é modificar a aplicação. E sim, saber como documentar, o que aconteceu. Aprendendo com os erros e melhorando a sim mesmo em termos de conhecimento. GIT como eu disse a pouco, é um forma muito boa de você aprender e documentar as suas experiências na programação. A forma de se fazer isto, é bem simples e direta. Isto uma vez que você tenha feito os passos que mostrarei.

Para que você consiga compreender o poder desta ferramenta. Ao pega uma aplicação qualquer, como por exemplo, este sistema de replay / simulador, que estou mostrando. E o modifica para averiguar se sua hipótese funciona ou não. Fica difícil você depois de um tempo, saber o que foi modificado. Ainda mais se a modificação tiver que ocorrer em diversos pontos. Fazer isto sem o uso de uma ferramenta adequada é muito complicado. Você acaba se perdendo em meio as mudanças e isto desestimula você a estudar e se profissionalizar. Mas o GIT faz isto para você. Você pode modificar a aplicação, testar as modificações que você fez. Se sua hipótese estiver correta, poderá ter um documento final dizendo exatamente o que foi modificado. Isto é ou não é algo fantástico ?!?! Eu mesmo quando aprendi, tinha que fazer as coisas na unha. Mas com o GIT, você verá as coisas ali, sendo destacadas.

GIT se baseia em um conceito muito simples. Em seu modelo mais básico, ele se parecerá muito com uma lista encadernada de modificações. Muito parecido com um diário. Isto conforme você vai fazendo as anotações. Veremos como fazer isto depois. Mas em um modo mais amplo, ele será um grafo. Sendo um grafo, ele pode assumir qualquer forma, podendo nos dar diversas direções em uma mesma implementação. Onde cada uma das direções permitirá desenvolver ideias correlacionadas. Se você nunca viu, ou não sabe o que é um grafo. Você pode ter uma ideia olhando a imagem abaixo:

Basicamente cada um os pontos, temos um valor que é conhecido como NÓ. As linhas que ligam cada um, é conhecida como ARESTA. Este é um grafo simples, mas ele pode ser muito mais complicado. Vale muito você estudar sobre grafos. Ainda mais se você pretende, realmente se tornar um profissional. Mas não comece diretamente pelos grafos. Comece com as listas, depois veja sobre árvores e por fim, estude os grafos. Assim você aprenderá as coisas de forma mais linear.

Começando com o básico

A parte mais básica de todas é de fato, baixar a última versão do GIT. Para isto você deverá acessar o seguinte link: git-scm.com neste mesmo site você terá acesso, a documentação. Muito deste material já se encontra traduzido. Mas mesmo que não esteja, você encontrará muita gente explicando sobre o assunto. É só pesquisar e estudar. Então aqui quero apenas mostrar o básico para quem não conhece GIT.

Se você estiver utilizando, o Windows, bastará clicar na parte mostrada na imagem abaixo:

No momento que escrevo este artigo, esta é a versão mais atual. Uma vez que você baixou a versão mais atual do GIT. Você deverá instalar o mesmo em sua máquina. A instalação pode ser feita, pelo padrão. Porém eu faço uma pequena mudança, esta pode ser vista na imagem abaixo:

Você não precisa fazer isto. Dá para mudar o editor depois. Mas como gosto de usar o NotePad++, digo ao GIT para usar ele. Se você depois decidir usar um outro, bastará mudar uma variável global do GIT. A variável em questão é a CORE.EDITOR, consulte a documentação para mais detalhes. Muito bem, uma vez que o GIT esteja instalado, você precisa começar a configurar o mesmo. Mas não se preocupe, esta parte é bem simples de ser feita. Explicarei isto com calma, para que você tenha uma ideia de como começar. Ao terminar a instalação o GIT, você passará a ter acesso ao que se encontra destacado na imagem abaixo:

É justamente estas duas opções que não aparecem no Windows 11. Por isto recomendo você usar o Windows 10. Apesar de ser possível acionar estas opções no Windows 11, será necessário fazer alguns passos que fogem do escopo deste artigo. Um detalhe: Você não precisa destas opções. Mas o acesso a elas facilitará muito o trabalho, tornando a experiência mais agradável. Se você clicar na opção Git GUI Here, a seguinte janela será mostrada:

Aqui você pode abrir, clonar ou criar um repositório. Mas queremos fazer uso do GIT junto com o MQL5. Então não clique em nada ainda. Não se preocupe com a opção Git Bash Here. O foco aqui será a GUI, mas muitos explicam como usar o BASH, é só pesquisar na WEB. Já que a ideia é apresentar o GIT, vou usar a parte mais simples dele, ou seja a GUI. Mas tudo que se faz em uma interface, se pode fazer na outra. É mais uma questão de costume. Para iniciar, abra o MetaEditor e clique no ponto em destaque na imagem abaixo:

Isto fará com que a seguinte janela se abra:

Agora você precisa, permitir que os arquivos e pastas ocultas sejam visíveis. Isto para você poder fazer um backup local do GIT. Apesar de tudo, você pode usar o GITHUB. Mas aqui quero ser o mais simples, quanto for possível. Então acesse as opções do Explorer e mude o seguinte parâmetro.

Marque a opção que está em destaque, clique em aplicar e depois clique em ok. Com isto agora poderemos ver a pasta que será criada pelo GIT. Já que ainda não temos nenhum repositório. Nenhuma pasta será mostrada. Mas agora clique novamente com o botão direito do mouse, e selecione Git GUI Here. Depois clique em Create New Repository e você verá a seguinte janela.

Agora clique no botão Browse, e a seguinte janela será aberta:

Apenas clique em Select Folder e você verá seguinte imagem:

Clique no botão Create, e o resutado será este:

Esta pasta que está em destaque na imagem acima é justamente o que desejávamos criar. Na mesma hora em que esta pasta for criada, uma nova janela se abrirá. Você pode ver a mesma na imagem abaixo.

Agora repare que na região marcada existem arquivos do tipo EX5. Estes arquivos são aplicações que podem ser executadas no MetaTrader 5. Mas não queremos ver estes arquivos, poluindo a pesquisa. Para remover este e qualquer outro tipo, devemos fazer uma pequena edição. Isto para este repositório que estamos configurando. Mas se você desejar, sinta-se a vontade de modificar as coisas de forma global. O GIT permite você trabalhar de ambas maneiras. Para limpar estes arquivos indesejáveis, você não precisa apagar os mesmos. Bastará fazer o que é mostrado na imagem abaixo:

Observe o caminho, e o arquivo que precisamos modificar. Agora abra o arquivo, e você verá, inicialmente o seguinte conteúdo:

# git ls-files --others --exclude-from=.git/info/exclude
# Lines that start with '#' are comments.
# For a project mostly in C, the following would be a good set of
# exclude patterns (uncomment them if you want to use them):
# *.[oa]
# *~

Você pode apagar este conteúdo, já que ele é composto de apenas comentários. De qualquer forma, você deverá adicionar algumas linhas nele. No caso desejamos que todos os arquivos com extensão EX5, não sejam mostrados, assim como outras coisas também. Então modifique o arquivo como é visto abaixo. Veja a documentação para mais detalhes. E salve o arquivo.

O que estamos fazendo é dizendo ao GIT, que neste repositório, alguns tipos deverão ser ignorados. Mas o filtro deverá onde mostrei. O sistema de filtragem conta com muitas opções, então estude a documentação. Quanto melhor for a filtragem, mais fácil será a próxima etapa. Uma vez que o arquivo foi salvo, volte a janela do GIT GUI e clique no botão RESCAN que se encontra em destaque na imagem abaixo. Observe que aqueles arquivos com extensão EX5, não aparecem mais. Role a tela e compare com o que havia antes de você editar o arquivo.

Até agora não fizemos nada. Apenas dizemos ao GIT, onde será o repositório e o que ele deverá filtrar. Uma observação importante: Quando você for salvar as coisas, não precisará salvar tudo que estiver na pasta MQL5. Bastará salvar a pasta .GIT e tudo que o GIT estivesse observando será preservado. Isto poupa um bocado de espaço. Mas como foi dito, você pode salvar tudo em nuvem via GITHUB. Mas o conteúdo salvo será exatamente o repositório na pasta .GIT

Mas então, quando vamos começar a salvar as coisas no GIT ?!?! Calma meu caro leitor. Calma, já estamos quase lá. Falta ainda alguns pequenos detalhes a serem configurados. Para configurar esta última parte, você deve selecionar o que está sendo destacado na imagem abaixo.

Isto fará com que uma nova janela se abra. Esta pode ser vista abaixo, onde você pode notar que temos algo, aparentemente duplicado. Mas não está duplicado. Observe com atenção.

Veja que temos duas marcações. Uma do lado direito e outra do lado esquerdo. A do lado esquerdo, fará a configuração dos dados sobre este repositório. Já a do lado direito, fará a configuração global. Isto é, para todo e qualquer repositório que for criado. Você pode configurar um ou outro, ou se desejar ambos. Mas sugiro você fazer a configuração global, assim assim você não ficar fazendo isto a todo momento. Então coloque nos campos em destaque, uma identificação pessoal. E vamos para o próximo tópico, pois agora terminamos de configurar as coisas mais básicas.

Criando o primeiro COMMIT

Agora que fizemos o básico, você precisa entender uma coisa. No GIT, temos três estados básicos. Estes são os estados que um arquivo pode se encontrar dentro do GIT.

• O primeiro estágio, é o chamado estágio COMMITTED. Neste, o arquivo com todos os seus dados estão armazenados de forma segura dentro do repositório.
• O segundo estágio, é chamado de MODIFIED. Neste, o arquivo foi modificado, e tais mudanças ainda não foram salvas no repositório.
• O terceiro e último estágio, é o STAGED. Que é quando você diz ao GIT, que o arquivo se encontra pronto para ser salvo no repositório.

Para exemplificar as coisas e assim você entender melhor, o que cada um destes estágios significa. Vamos fazer o seguinte: Observe na imagem abaixo, que temos o arquivo ExpertMACD.mq5. O mesmo está como UNSTAGED, ou seja, o GIT não o está observando.

Vamos fazer com que o GIT passe a observar, e acompanhar as modificações deste arquivo. Para isto clique no mesmo. Observe que na área a direita, podemos ver o conteúdo atual do arquivo.

Na parte superior do conteúdo do arquivo você pode observar a palavra UNTRACKED, que significa que o arquivo ainda não está sendo observado pelo GIT. Então para fazer o GIT observar o arquivo, você deverá usar o que é mostrado abaixo:

Usando esta opção, ou o atalho CTRL + T, você terá como resultado o que é visto na imagem, imediatamente abaixo:

Observe como as coisas mudaram. Agora o arquivo está com a palavra STAGED FOR COMMIT, ou seja, ele se encontra no terceiro estágio, pronto para ser armazenado. Se você não desejar adicionar este arquivo, bastará selecionar ele é usar o atalho CTRL + U, isto fará com que ele saia do modo STAGED e vá para o UNTRACKED. Detalhe: Um arquivo já tem outras forma de removido. Estude a documentação para mais detalhes. Aqui quero manter as coisas no mais básico possível.

Então vamos colocar junto deste arquivo, os seus arquivo de cabeçalho. Assim teremos o que pode ser visto na imagem abaixo:

Com isto, já podemos criar o primeiro COMMIT. Para fazer isto, bastará clicar no botão COMMIT. Porém, é de boa prática, e até mesmo adequado, você colocar algum comentário antes de clicar no botão COMMIT. Isto para facilitar encontrar e entender as modificações depois.

A imagem acima mostra qual será a nossa mensagem. Logo depois clique no botão COMMIT. Assim o GIT passará a observar estes arquivos que indicamos. O resultado será o que é visto abaixo.

Observe na área marcada, que o GIT obteve sucesso na criação do COMMIT. Com isto, o GIT passará a observar estes arquivos. Agora você pode fechar esta janela do GIT GUI. Trabalhar no código, testar e modificar a vontade. Quando terminar e tendo uma versão, que ao seu ver se encontra estável. Você terá que pedir ao GIT para atualizar o repositório. Para separar as coisas, vamos ver isto em um outro tópico.

Atualizando o repositório

Atualizar o repositório, em muitos casos é mais simples via BASH, mas vou mostrar como fazer via GIT GUI. Para isto, é usando o botão mostrado em destaque na imagem abaixo:

Ao fazer isto, o GIT verificará, onde e o que foi modificado. O arquivo que está sendo rastreado e que foi modificado. Isto estará sendo mostrado novamente como UNSTAGED. Você pode ver isto na imagem acima. Observe que ele o arquivo, se encontra no estágio MODIFIED, e na janela que podemos ver o conteúdo, o GIT nos mostra o que foi modificado. Isto está aparecendo em destaque na cor verde. Você pode mudar esta cor nas opções. Mas como quero apenas mostrar o básico. Fica ao seu critério fazer estas mudanças.

Agora depende de você aceitar e armazenar esta modificação ou ignorar a mesma. Pois é isto mesmo, se você desejar, o GIT consegue fazer com que o arquivo, volte em um estado anterior. Pense nisto, como aquelas opções presentes no Windows, como sendo pontos de restauração. Por conta disto, que você precisa sempre colocar, uma mensagem adequada no momento de fazer um novo COMMIT.

Então vamos aceitar as modificações e as salvar. Assim, depois de adicionar uma mensagem adequada e clicar no botão de COMMIT, veja o que acontecerá.

E por que isto aconteceu ?!?! O motivo é por que, as modificações, não estão no estágio STAGED, ou seja, elas ainda não estão prontas para que o GIT possa as documentar, elas estão no estágio MODIFIED. Para adicionar os arquivos que estão no estágio MODIFIED, para o estágio STAGED, você simplesmente pressiona CTRL + I. Mas existe um detalhe, veja na imagem abaixo:

Se você pressionar o botão de SIM, todos os arquivos, no caso os 403 arquivos, serão adicionados no estágio STAGED. Mas como queremos que apenas os arquivos que estão sendo observados e que foram modificados sejam adicionados, devemos pressionar o botão de NÃO. E o resultado será este mostrado abaixo:

Com isto você já pode pressionar o botão COMMIT, para que o GIT documente as mudanças, que antes não foi possível fazer. Entenderão agora. O GIT apenas documentará no repositório, arquivos que estejam no estágio STAGED. Todos os outros serão ignorados. Muito bem, este tópico, foi fácil. Mas se desejarmos descartar as modificações, por que o código ficou todo enrolado. Como o GIT pode nos ajudar a descartar as mudanças ?!?! Bem isto será explicado no próximo tópico.

Descartando as modificações...

Para fazer o descarte das mudanças que você fez, e reaver o que o GIT documentou no repositório. É algo bem simples, você deverá seguir os mesmos passos que foram utilizados no tópico anterior. De maneira que deveremos ver as mudanças, como mostrado na imagem abaixo.

Veja que temos uma nova modificação. E que se encontra sendo mostrada em destaque. Mas queremos que ela seja removida. Então pedimos ao GIT para fazer isto. Este pedido é feito usamos o atalho CTRL + J. Ou se preferir usando o que é mostrado na imagem.

Ao fazer isto o GIT irá lhe pedir a confirmação do que será feito. Isto pode ser visto na imagem abaixo:

Se você aceitar, o GIT reverterá o conteúdo do arquivo. Colocando nele o conteúdo que estiver no topo do repositório. Se o arquivo estiver aberto no MetaEditor, você notará que o MetaEditor lhe pedirá para recarregar o arquivo. Assim que isto for feito, você notará que as mudanças foram removidas pelo GIT. É importante você entender isto. Pois sabendo e entendendo isto, você conseguirá entender o próximo tópico.

Retornando o código a uma versão mais estável

Talvez uma das coisas mais bacanas é justamente fazer isto. Voltar para uma versão em que o código estava bem mais estável. Fazer isto sem usar o GIT é algo muito complicado e em alguns casos é impossível fazer isto. Nos forçando a descartar todo o código e começar do zero. Mas fazer isto via GIT é bem simples e direto. Para isto, você pode selecionar uma das opções marcadas abaixo.

Isto abrirá a janela mostrada logo abaixo:

Agora veja o motivo de sempre colocar mensagens adequadas. Assim será mais simples entender as mudanças, e encontrar uma versão estável. Então você pode navegar, e escolher a versão que você deseja reaver. Uma vez selecionada a versão, você deverá clicar com o botão direito e selecionar o item que se encontra em destaque.

Uma vez feito isto, uma nova janela irá se abrir. Aqui você deve tomar cuidado. Se você NÃO DESEJA remover do repositório alguma coisa, selecione a opção mostrada abaixo:

O resultado desta ação pode ser visto abaixo.

Preste atenção que o indicador de topo do repositório mudou. Isto é justamente o que desejamos. Já que o topo do repositório, mostra o que poderemos reaver no código. Agora volte na janela da GUI e selecione a opção mostrada abaixo.

Com isto, todo o código que se encontra no topo do repositório, que agora é uma versão anterior, será recolocado nos devidos arquivos. Um detalhe, se algum arquivo havia sido apagado, o GIT recriará o arquivo. Por isto entender qual é o topo do repositório é tão importante. Sem entender isto, você não conseguirá voltar para uma versão anterior. Mas antes das mudanças serem aplicadas, lhe é pedido uma confirmação como mostrado abaixo.

Muito bem, agora você já sabe como voltar para uma versão anterior. Mas e se você voltou muito. Como fazer para voltar a uma versão mais recente ?!?! Para não confundir as coisas, vamos ver isto em um novo tópico.

Retornando para uma versão mais recente dentro do repositório

As vezes durante o retorno a uma versão mais estável, acabamos retornando muito, e precisamos voltar a uma versão mais recente. Para exemplificar isto, precisamos criar um terceiro nível. Já que usando apenas dois níveis, não será possível entender como fazer isto, via GUI. Já via BASH é bem mais direto, pois teremos apenas que enviar um comando para o GIT. Mas quero mostrar como fazer via GUI. Então vamos supor que tenhamos o seguinte cenário, mostrado abaixo.

Note que agora temos três níveis. Então decidimos retornar ao primeiro nível, assim o resultado seria o que pode ser visto abaixo. Lembrando que para fazer isto, usaremos os passos vistos no tópico anterior.

Neste ponto você imagina que deve ter retornado muito. Então decide subir para no segundo nível, para verificar se o código seria adequado. Como proceder neste caso ?!?! Este é um caso interessante e existem diversas formas de se lidar com ele. Mas você não deve jamais entrar em desespero. Então antes de ver como fazer isto, vamos ver um pequeno detalhe, que pode ser importante. Se você olhar dentro da pasta .GIT notará a existência de um arquivo que não estava ali. Isto pode ser notado na imagem abaixo.

O conteúdo deste arquivo é um HASH, este é útil para você conseguir recuperar, em caso de fazer uma grande cagada, os dados que o GIT tem no repositório. Você pode ver estes HASH ao olhar o conteúdo neste ponto em destaque abaixo:

Mas não vou entrar em detalhes de como usar este HASH, pois está tudo na documentação e tem muitos tutoriais mostrando como fazer isto na WEB. Mas vamos voltar a questão de como obter os dados que estão no segundo nível. Uma vez que você selecione o segundo nível, você o deverá tornar o topo do repositório. É sempre assim. Porém você deve tomar cuidado para não selecionar erroneamente o modo HARD, deve sempre dar preferência de usar o modo SOFT. Assim como mostrado na imagem abaixo.

Ao selecionar adequadamente as opções, você terá o resultado mostrado abaixo.

Isto permitirá a você ter acesso ao código mais recente. E é assim que você vai navegando entre as versões que o GIT armazenou no seu repositório. Mas vamos supor que você deseje remover e descartar as modificações mais novas. Então para fazer isto você faria a escolha que é mostrada logo abaixo:

Isto fará com que o resultado seja visto abaixo:

Existe um último comando a ser visto. Suponhamos que você tenha baixado, ou deseje repor todo um repositório de um backup. O motivo não importa, mas você simplesmente deseja repor as coisas na última versão que se encontra no repositório, antes de você o apagar do disco. Você pode fazer isto, arquivo por arquivo, mas também pode usar o que se encontra em destaque na imagem abaixo.

Quando você selecionar esta opção, todo o conteúdo do repositório, será revivido, como se magicamente, os arquivos e diretórios voltassem a existir. Use esta opção, sempre que precisar repor todo um repositório, que estava guardado como backup. Isto para voltar a trabalhar rapidamente no projeto.

Considerações finais

Aqui neste artigo mostrei as questões mais básicas para se poder usar o GIT. Espero que este artigo sirva de incentivo para que você estude e procure sempre se aperfeiçoar. Pois as ferramentas existem, mas não espere simplesmente que alguém venha e lhe mostre como usá-las. É preciso que você esteja sempre disposto a procurar aprender coisas novas. E não achem que GIT é apenas o que mostrei aqui. Ele é muito mais e pode lhe ajudar muito. Mas pelo menos, espero ter aguçado a sua curiosidade a respeito do GIT.