Sistemas de controle de versão

"Olá, amigo!"

"Oi!"

"Hoje vou falar sobre sistemas de controle de versão."

"Como você provavelmente já sabe, os programas geralmente são muito grandes e levam muito tempo para serem escritos. Às vezes, dezenas de pessoas podem passar anos escrevendo um programa."

"Projetos com milhões de linhas de código são uma realidade."

"Uau."

"É tudo muito complicado. Muitas vezes as pessoas interferem umas nas outras, muitas vezes modificam o mesmo código e assim por diante."

"Para colocar ordem nessa bagunça, os programadores começaram a usar sistemas de controle de versão para seus códigos."

" Um sistema de controle de versão é um programa que consiste em um cliente e um servidor.

"O programa armazena dados (o código escrito por programadores) em um servidor, e os programadores adicionam ou alteram usando clientes."

"A principal diferença entre um sistema de controle de versão e programas que simplesmente possibilitam o trabalho colaborativo em documentos é que ele armazena todas as versões anteriores de todos os documentos (arquivos de código)".

"Você pode me dar mais detalhes. Como tudo isso funciona?"

"Imagine que você é um programador e deseja fazer pequenas alterações no código-fonte de um programa armazenado em um repositório no servidor."

"Aqui está o que você precisa fazer:"

"1) Faça login no servidor."

"2) Copie a versão mais recente de todos os arquivos para o seu computador usando o comando Checkout."

"3) Faça alterações nos arquivos necessários."

"4) Execute o programa localmente para garantir que ele seja compilado e executado."

"5) Envie suas 'alterações' para o servidor usando o comando Commit."

"Isso geralmente faz sentido."

"Mas há mais. Imagine que você chega ao trabalho de manhã, mas já é hora do almoço na Índia. Portanto, seus colegas indianos já fizeram alterações e enviaram suas alterações para seu repositório no servidor."

"Você precisa trabalhar com a versão mais recente do código. Portanto, execute o comando Atualizar ."

"Como isso é diferente do Checkout ?"

" O Checkout foi projetado para copiar todos os arquivos do repositório, mas o Update atualiza apenas os arquivos que foram atualizados no servidor desde a última vez que você executou um comando Checkout / Update ."

"É mais ou menos assim que funciona:"

Check-out :

"Agora, digamos que alteramos o arquivo B e queremos enviá-lo para o servidor. Para fazer isso, precisamos usar o comando Commit ."

"E aqui está como o comando Atualizar funciona:"

"Que interessante! Existem outros comandos?"

"Sim, existem alguns. Mas eles variam dependendo de qual programa de controle de versão você escolher. Então, estou tentando apenas explicar os princípios gerais."

"Também existe uma operação chamada fusão - a união de dois documentos. Suponha que dois programadores modifiquem o mesmo arquivo ao mesmo tempo. Então o programa no servidor não permitirá que ambas as alterações sejam confirmadas. Quem confirmar primeiro adiciona seu ou suas mudanças."

"Então, o que a outra pessoa faz?"

"Ele ou ela será convidado a executar uma operação de atualização para obter as alterações mais recentes do servidor. A propósito, isso - fazer uma atualização antes de confirmar - é uma boa prática."

"Então, durante a operação de atualização, o programa cliente tentará mesclar as alterações locais com as alterações recebidas do servidor."

"Se os programadores alteraram diferentes partes do arquivo, o programa de controle de versão provavelmente será capaz de mesclá-los com sucesso.  Se as alterações estiverem no mesmo local, o programa de controle de versão relatará um conflito de mesclagem e solicitará que o usuário manualmente mesclar as alterações."

"Por exemplo, isso geralmente acontece quando ambos os programadores adicionam algo ao final de um arquivo."

"Entendo. No geral, isso parece razoável."

"E tem mais uma coisa: galhos."

"Imagine que dois programadores de uma equipe tenham a tarefa de reescrever o mesmo módulo. Ou, melhor ainda, reescrevê-lo do zero. Até que este módulo seja concluído, o programa não poderá ser executado e nem mesmo compilado."

"Então, o que eles deveriam fazer?"

"Eles avançam adicionando ramificações ao repositório. Grosso modo, isso significa que o repositório é dividido em duas partes. Não por arquivos ou diretórios, mas por versões."

"Imagine que a eletricidade nunca foi descoberta e os robôs nunca foram inventados. Então as três guerras de libertação nunca teriam acontecido e toda a história da humanidade teria seguido um caminho completamente diferente. "

"Este caminho é um ramo alternativo da história."

"Ou você pode apenas tentar imaginar uma ramificação simplesmente como uma cópia do repositório. Em outras palavras, em algum momento, fizemos um clone do repositório no servidor, para que, além do repositório principal (muitas vezes chamado de trunk ), temos outra filial ."

"Bem, isso parece mais compreensível.

"Por que você não pode simplesmente dizer que copiamos o repositório?"

"Isso não é uma cópia simples."

"Esses galhos não só podem ser separados do tronco, mas também fundidos nele."

"Em outras palavras, algum trabalho pode ser feito em uma ramificação e, quando terminar, você pode adicionar a ramificação do repositório ao tronco do repositório?"

"Sim."

"E o que vai acontecer com os arquivos?"

"Os arquivos serão mesclados."

"Bem, isso parece legal. Espero que seja tão legal quanto em ação."

"E mais alguns. Ok, vamos fazer uma pausa."

"Há um monte de informações úteis  aqui "