Por que devo usar o controle de versão? [fechadas]

Eu estava lendo um blog onde o escritor disse isso

"O código não existe, a menos que esteja registrado em um sistema de controle de versão. Use o controle de versão para tudo o que você faz. Qualquer controle de versão, SVN, Git e até CVS, domina e usa."

Eu nunca usei nenhum tipo de controle de versão e não acho tão bom assim. Eu pesquisei no Google e olhei para ele antes, mas só preciso colocá-lo em termos de crianças, se você quiser.

Pelo que entendi agora, coisas como SVN são para armazenar seu código on-line para que um grupo de usuários ou outros desenvolvedores tenham acesso ao mesmo código. Depois de atualizar algum código, você pode enviar a nova versão e o SVN manterá cópias do código antigo e dos novos que você atualizar.

Essa é a idéia básica disso ou estou entendendo completamente errado?

Se eu estiver certo, pode não ser muito útil se:

• Não tem outras pessoas trabalhando no código.
• Não planeje deixar que outras pessoas tenham o código.

Você já:

• Alterou o código, percebeu que era um erro e queria voltar?
• Perdeu o código ou tinha um backup muito antigo?
• Tinha que manter várias versões de um produto?
• Queria ver a diferença entre duas (ou mais) versões do seu código?
• Queria provar que uma alteração específica quebrou ou corrigiu um pedaço de código?
• Queria revisar o histórico de algum código?
• Queria enviar uma alteração ao código de outra pessoa?
• Queria compartilhar seu código ou permitir que outras pessoas trabalhem no seu código?
• Queria ver quanto trabalho está sendo feito e onde, quando e por quem?
• Queria experimentar um novo recurso sem interferir no código de trabalho?

Nesses casos, e sem dúvida em outros, um sistema de controle de versão deve facilitar sua vida.

Para citar mal um amigo: Uma ferramenta civilizada para uma era civilizada.

Mesmo se você trabalha sozinho, pode se beneficiar do controle de origem. Entre outros, por estes motivos:

• Você não perde nada. Nunca mais comentei o código. Eu simplesmente apago. Não atrapalha minha tela e não está perdida. Eu posso recuperá-lo verificando um commit antigo.

• Você pode experimentar à vontade. Se não resolver o problema, reverta-o.

• Você pode ver as versões anteriores do código para descobrir quando e onde os bugs foram introduzidos. git bisecté ótimo nesse sentido.

• Recursos mais "avançados", como ramificação e fusão, permitem que você tenha várias linhas paralelas de desenvolvimento. Você pode trabalhar em dois recursos simultâneos sem interferência e alternar entre as opções sem muito aborrecimento.

• Você pode ver "o que mudou". Isso pode parecer básico, mas é algo que me vejo checando bastante. Frequentemente começo o meu fluxo de trabalho individual: o que fiz ontem?

Apenas vá em frente e tente. Comece devagar com os recursos básicos e aprenda os outros à medida que avança. Você logo descobrirá que nunca mais voltará à "idade das trevas" de nenhum VC.

Se você quer um VCS local, pode configurar seu próprio servidor de subversão (o que eu fiz no passado), mas hoje eu recomendaria o uso git. Muito mais simples. Simplesmente cdno seu diretório de código e execute:

git init

Bem-vindo ao clube.

O controle de versão é uma ferramenta rara que eu diria ser absolutamente necessária, mesmo se você o estiver usando apenas como desenvolvedor solo. Algumas pessoas dizem que é uma ferramenta pela qual você vive e morre, eu concordo com essa afirmação.

Você provavelmente usa o controle de versão agora, mesmo que não o conheça. Você tem alguma pasta que diga "XXX Php Code (December)" ou "XXX.php.bak.2"? Essas já são formas de controle de versão. Um bom sistema de controle de versão cuidará disso automaticamente. Você poderá reverter para qualquer ponto no tempo (em que os dados foram verificados) e poderá ver uma cópia exata desses dados.

Além disso, se você adotar um sistema como o subversion e usar um repositório remoto (como o servidor que você possui), você terá um local para guardar todo o seu código. Precisa de uma cópia do seu código em outro lugar? Não tem problema, basta conferir. Falha no disco rígido em casa? Não é um problema (pelo menos com o seu código-fonte).

Mesmo se você não usar o controle de versão agora, provavelmente o usará em um momento posterior da sua carreira e poderá se beneficiar de se sentir mais confortável com os princípios agora.

Mesmo trabalhando sozinho, isso já aconteceu? Você executa o aplicativo e algo não funciona e você diz "isso funcionou ontem e eu juro que não toquei nessa classe / método". Se você estiver verificando o código regularmente, um diff de versão rápida mostrará exatamente o que mudou no último dia.

Aqui está um cenário que pode ilustrar a utilidade do controle de origem, mesmo se você trabalhar sozinho.

Seu cliente solicita que você implemente uma modificação ambiciosa no site. Você levará algumas semanas e envolverá edições em muitas páginas. Você começa a trabalhar.

Você termina 50% dessa tarefa quando o cliente liga e pede para você largar o que está fazendo para fazer uma alteração urgente, porém menor, no site. Você não terminou a tarefa maior, portanto ela não está pronta para ser lançada e o cliente não pode esperar pela alteração menor. Mas ele também quer que a mudança menor seja mesclada ao seu trabalho para uma mudança maior.

Talvez você esteja trabalhando na grande tarefa em uma pasta separada contendo uma cópia do site. Agora você precisa descobrir como fazer pequenas alterações de uma maneira que possa ser implantada rapidamente. Você trabalha furiosamente e consegue. O cliente retorna com mais solicitações de refinamento. Você também faz isso e o implementa. Tudo está bem.

Agora você precisa mesclá-lo ao trabalho em andamento para a grande mudança. O que você mudou para o trabalho urgente? Você estava trabalhando rápido demais para fazer anotações. E você não pode apenas diferenciar os dois diretórios facilmente agora que ambos têm alterações em relação à linha de base da qual você iniciou.

O cenário acima mostra que o controle de origem pode ser uma ótima ferramenta, mesmo se você trabalhar sozinho.

• Você pode usar ramificações para trabalhar em tarefas de longo prazo e, em seguida, mesclar a ramificação novamente na linha principal quando terminar.
• Você pode comparar conjuntos de arquivos inteiros com outros ramos ou com revisões anteriores para ver o que é diferente.
• Você pode acompanhar o trabalho ao longo do tempo (o que é ótimo para relatórios e faturamento, por sinal).
• Você pode recuperar qualquer revisão de qualquer arquivo com base na data ou em um marco que você definiu.

Para trabalhos individuais, recomenda-se o Subversion ou Git. Qualquer um é livre para preferir um ou outro, mas é claramente melhor do que não usar nenhum controle de versão. Bons livros são " Pragmatic Version Control using Subversion, 2nd Edition " de Mike Mason ou " Pragmatic Version Control Using Git " de Travis Swicegood.

Autor original: Bill Karwin

Mesmo como um único controle de fonte de desenvolvedor, oferece um grande benefício. Ele permite que você armazene o histórico do seu código e volte a versões anteriores do seu software a qualquer momento. Isso permite flexibilidade sem medo de experimentar, porque você sempre pode restaurar para outra versão do seu código-fonte que estava funcionando.

É como ter um botão gigante "desfazer" até a sua primeira linha de código.

É quase impossível viver sem controle de versão depois que você começa a usá-lo. É indispensável se mais de um desenvolvedor estiver trabalhando na mesma base de código ... mas também é bastante útil para um único desenvolvedor.

Ele rastreia as alterações no seu código e permite reverter para as versões anteriores. Isso libera você para experimentar o conhecimento de que, se algo quebrar, você pode desfazer suas alterações.

Você ganha segurança (no sentido de ter um backup do seu código) e versão do seu código (supondo que você tenha o hábito de confirmar suas alterações com frequência). Ambas são coisas muito boas, mesmo que ninguém mais acabe trabalhando no código com você ...

O controle de versão é ótimo para verificar versões anteriores, mesmo se você estiver trabalhando sozinho. Por exemplo, se você excluir acidentalmente um código ou um arquivo, poderá recuperá-lo; ou você pode comparar as versões anteriores para ver por que um novo bug apareceu. Também é bom se você é uma pessoa que trabalha em vários locais.

Meu favorito pessoal é git.

Existem várias razões para usar o controle de versão, mesmo se você for a única pessoa que jamais tocará no código.

• Backup - e se o seu disco rígido travar? Você tem uma cópia em algum lugar?
• Histórico de Revisão - Você atualmente mantém cópias de código em pastas diferentes? O controle de versão permite rastrear suas alterações ao longo do tempo e diferenciar facilmente diferentes revisões, mesclar, reverter alterações etc. usando ferramentas.
• Ramos - a capacidade de testar algumas mudanças, ainda acompanhar o que você está fazendo e depois decidir se você deseja mantê-lo ou não e se fundir ao projeto principal ou simplesmente jogá-lo fora.

Se você mantiver seu código sob controle de versão, será muito fácil ver quais arquivos foram alterados (ou se esqueceram de adicionar à linha de base).

Algo que ninguém mais parece ter mencionado explicitamente é a marcação ou rotulagem de lançamentos. Se você tem um cliente usando a versão 1 do seu software e está ocupado trabalhando na versão 2, o que você faz quando o cliente relata um erro e precisa criar a versão 1.1?

Um sistema de controle de origem permitirá rotular todas as versões que você faz para que você possa voltar mais tarde, fazer a correção (e mesclar essa correção no novo código da versão 2) e fazer uma nova versão sem se preocupar com a possibilidade de entregar acidentalmente algo que não está pronto.

O controle de fonte é uma parte essencial do desenvolvimento de software moderno. Se você não estiver usando (mesmo em projetos pessoais, quanto mais experiência tiver, melhor), estará fazendo algo errado.

Geralmente, uma das primeiras perguntas que faço ao ser entrevistada para um trabalho é "O que você usa para o controle da fonte?" Até agora, apenas um lugar disse "Nada", mas eles planejavam consertar esse "Muito em breve ..."

O fato de outros desenvolvedores participarem ou não é totalmente ortogonal à necessidade de um sistema de controle de versão.

Você pode ser o único desenvolvedor, mas ainda se beneficiará de:

• uma trilha histórica de todas as suas alterações
• capacidade de voltar e avançar nessa história
• capacidade de experimentar a fonte e ainda ter uma versão funcional (ramificação)
• uma cópia de backup (especialmente se você usar uma máquina diferente como servidor de controle de origem e ainda mais se for feito backup regularmente dessa máquina)

Agora, se você tem um grupo desenvolvendo o mesmo controle de versão da base de código, ainda é mais necessário.

• as pessoas podem editar o mesmo arquivo ao mesmo tempo (dependendo do sistema em particular, mas a maioria dos sãos permite que você faça isso)
• você pode dizer quem fez o que com o código quando

Quando há mais pessoas envolvidas, é mais relevante qual ferramenta de controle de versão você escolhe, dependendo do estilo de desenvolvimento.

Também se trata de fazer backup de arquivos antigos, por que é chamado de "Subversion". Assim, você pode gerenciar várias versões do seu trabalho, nas quais pode voltar (reverter) e gerenciar as diferentes implementações (ramificação).

Você pode achar que tinha uma versão funcional do seu programa.

Você decide adicionar alguns novos recursos por um período de tempo e o libera.

Você começa a receber relatórios de bugs que afetam algum código que julgou não ter tocado.

Usando o SVN, por exemplo, você pode voltar para uma versão mais antiga e verificar se o novo bug existe. Depois de encontrar uma versão que introduziu o bug, será mais fácil corrigi-lo, pois você poderá comparar a versão que funcionou com o que não funcionou e ver o que mudou. Em seguida, restringirá a pesquisa.

O controle de origem tem muitos usos, mesmo se você for o único desenvolvedor.

Parece que você está procurando algo um pouco mais leve. Confira o Mercurial ( livro de referência incrível ). Eu o uso para tudo, do código fonte à correspondência pessoal.

Alguns benefícios:

• Botão Desfazer gigante, para que você possa retornar os dias felizes da semana passada quando o código realmente foi executado
• Código de descarte. Não tem certeza se esta é a melhor maneira de fazer alguma coisa? Faça um ramo e experimente. Ninguém além de você precisa saber disso se estiver usando um DVCS como o mercurial.
• Desenvolvimento sincronizado. Eu desenvolvo em 4 computadores diferentes. Eu empurro e puxo entre eles para manter a corrente, então, não importa em qual eu estou, tenho as versões mais recentes.

Mesmo se você ainda não esteve em uma situação em que precisava de uma versão mais antiga do seu programa, ter um controle de origem lhe dará maior confiança para fazer grandes alterações.

Eu me vi fazendo refatoração mais agressiva depois de usar o controle de origem, porque sempre soube que uma versão de trabalho poderia ser facilmente restaurada.

Também recentemente comecei a me interessar pelo controle de versão. Nos sistemas de controle de versão, você tem o conceito de um repositório para o seu código. Muitos novos comandos do shell são aprendidos muito rapidamente, para que você possa interagir com este repositório.

Depois de salvar seu código em um arquivo, você poderá confirmar isso no repositório do seu projeto. À medida que você desenvolve seu código e confirma suas alterações, o repositório desenvolve uma série de revisões . Você pode acessar qualquer uma dessas opções consultando uma revisão. Se você trabalha sozinho, é pouco provável que faça muito check-out, a menos que perca seus arquivos de código ou queira trabalhar em uma máquina diferente. Nesses casos, você geralmente verifica a revisão mais recente de todos os arquivos.

Pela minha parte, não mantenho mais arquivos ou pastas com o nome 'project_old' quando decido refatorar algo. Quaisquer alterações que eu fizer são armazenadas de forma incremental e sempre poderei voltar para um projeto que funcionou como um todo. Raramente uso o FTP para implantar agora porque apenas faço check-out do meu código pelo ssh. Somente os arquivos que eu alterei são baixados e se eu precisar recarregar no servidor, o terminal já estará lá.

Achei essa palestra no GIT realmente instrutiva; http://www.youtube.com/watch?v=4XpnKHJAok8

É uma conversa no Google em que Linus Torvalds argumenta sobre o uso de um sistema de controle de versão sobre outro. Ao fazer isso, ele explica como eles funcionam usando conceitos e depois compara diferentes maneiras de implementá-los.

Você provavelmente desejará algo como subversão, mesmo que esteja trabalhando sozinho para ter um histórico de todas as suas alterações. Você pode querer ver como era um pedaço de código uma vez para lembrar por que você fez uma alteração.

Ter controle de origem também é útil quando você faz check-in com frequência. Se você fizer check-in com frequência, estará sempre em condições de reverter com frequência também. Muitas vezes você pode começar a seguir um caminho para resolver um problema e depois perceber que esse é o caminho errado. Muitas vezes, você pode continuar latindo no caminho errado e acabar criando uma solução terrível - apenas porque não queria perder todo o seu trabalho. Ao fazer o check-in com frequência, o último ponto da "felicidade" não está longe; portanto, se você seguir o caminho errado, sempre poderá reverter e tentar novamente e criar uma solução mais elegante e simples. O que é sempre bom, para que você possa entender e manter o que escreveu no futuro.

Depende do tamanho do projeto e da frequência com que você muda de idéia sobre partes dele. Para pequenos projetos em que você está fazendo algo de maneira linear, o controle de versão provavelmente não será de grande ajuda (embora, se você excluir ou corromper acidentalmente um arquivo sem o controle de versão, esteja chorando).

Mas algumas semanas atrás eu conheci um amigo que estava escrevendo um enorme projeto de hobby por conta própria. Ele tinha dez ou vinte cópias de seu código, com sufixos como "X1", "X2", "test", "mais rápido" e assim por diante.

Caso você tenha feito mais de duas cópias de seu código, você precisa de controle de versão . Um bom sistema de controle de versão permite desfazer uma alteração feita há um tempo atrás, sem desfazer o que você fez depois de fazer essa alteração. Permite ver quando determinadas alterações foram feitas. Ele permite que você divida seu código em dois "caminhos" (por exemplo, um para testar uma nova idéia, o outro para manter seu código "testado e confiável" em segurança até que você termine o teste) e depois os junte novamente.

É 2019. Estou encontrando objeções, nesta data relativamente recente, ao uso do Git; objeções Eu vejo alguns levantando aqui. Essa discussão esclareceu muito o imperativo de usar o controle de origem em vez de simplesmente fazer cópias de backup nomeadas. Um ponto importante é o uso do controle de origem, mesmo em projetos de desenvolvedor único. Ninguém é perfeito. Você comete erros. Se você é excepcionalmente bom e inteligente, estará desenvolvendo aplicativos mais complexos; mas você ainda cometerá alguns erros e isso lida com isso. Nossa, Pete! Eu nunca uso Linux, mas acho que todos respeitamos a grande inteligência técnica de Linus Torvalds. Ele reconheceu a importância do controle de fontes e fez contribuições importantes para o início do Git. Esse é um ponto de resumo por todas as razões apresentadas aqui. Torvalds entende: o controle de origem é muito importante: use o controle de origem. Obrigado a todos que comentaram este tópico de longa duração.