Estratégia de controle de versão svn

Estratégia de controle de versão svn
Obter através da App Store Leia esta publicação em nosso aplicativo!
Vindo com uma estratégia de controle de versão para o SVN.
No horário vou tentar criar uma estratégia de controle de versão para minha empresa; Atualmente, usamos o SVN, mas não há estrutura - basicamente, basicamente, temos um baú e só nos comprometemos com isso. Recentemente, o gerente de desenvolvimento iniciou um segundo repositório que atua como nossa "tag", mas deve ser mesclado manualmente com o "tronco", uma vez que não é parte do mesmo repositório, mas totalmente separado. Na verdade, há apenas uma pasta, chamada "Dev" (há pastas diferentes "Dev" em datas diferentes, mas apenas "Dev" é o principal) e sob isso é tudo o resto; todos os outros projetos. Não é organizado por projeto, não tem conceito de ramos / tag / tronco ou qualquer coisa. A pessoa que o configurou inicialmente (há muito tempo, é claro) pareceu não saber como configurar SVN, e desde então ninguém se incomodou em aprender a fazer as coisas corretamente por medo de quebrar algo. Nós não usamos nenhum tipo de CI (ou testes automatizados, infelizmente).
Primeiro, devemos separá-lo por projeto? Por exemplo, temos: dois sites da ASP (não aplicativos da Web, sites da Web), um serviço da Web, uma pasta de implantação para todos os scripts de tabela e procedimentos armazenados, dois clientes de linha de comando para projetos externos que são chamados pelos WebSites e uma pasta compartilhada que possui objetos de negócios comuns e similares. Cada um deles deve ser seu próprio projeto com uma configuração de ramo / tag / tronco, ou deve ser assim:
e tem todos os ramos e tudo tem uma cópia de toda a pasta do Dev? Essa abordagem pode ser mais fácil de engolir, pois muitas vezes temos situações em que precisamos fazer alterações na biblioteca de códigos compartilhados e, pelo menos, um (geralmente ambos) dos sites.
Em segundo lugar, fazemos lançamentos regulares ("empurra" em nossa linguagem) para nosso servidor dev e servidor ao vivo. Do que eu li, a melhor maneira de lidar com isso seria que todo o desenvolvimento entra no tronco /, as agências são "temporárias" e usadas para adicionar um novo recurso que pode afetar o tronco e as tags são para lançamentos? Então, empurramos todos os meses, digamos, e estou trabalhando em um novo módulo. Eu englobaria o tronco e usaria esse ramo para o meu código, escrevendo e testando o mesmo. Quando o módulo estiver pronto, eu o combinarei novamente no tronco (e talvez apague o ramo), e quando estivermos prontos para a implantação, nós o marcaremos ("Maio 2018", digamos). Se tivermos uma correção de bugs depois de entrar em operação, seria corrigido na tag May2018 e mesclado no tronco (então o trunk também consegue a correção) e, em seguida, May2018 seria novamente descartado com a correção? É essa a intenção de marcar?
Se quiser um processo de compilação unificado, certifique-se de colocar ramos / tags / tronco na raiz, como este:
Se você não precisa de um processo de compilação unificado, pode colocar ramos / tags / troncos dentro de cada projeto se desejar. No entanto, pode ser difícil migrar para uma compilação unificada depois de colocá-los dentro de cada projeto. Uma compilação unificada tem vantagens, como a eliminação da necessidade de publicar componentes compartilhados entre os projetos - todos fazem parte da compilação.
Pessoalmente, eu gosto de um processo de compilação unificado. Além disso, não acho que você deveria ter um projeto "dev". Você deve ter projetos diretamente sob o tronco e, em seguida, ramificar o tronco para um ramo de dev. Use tags para lançamentos. Por exemplo, eu faria isso assim:
No que diz respeito à estrutura do código dentro do svn, esta é realmente uma escolha pessoal.
Eu sugeriria que, se os projetos estiverem relacionados ou compartilhando o código, eles querem um tronco comum. Se eles são independentes, eles querem troncos separados ou mesmo repositórios separados. Se você precisar fornecer um terceiro com uma cópia do histórico do svn para um projeto, então é muito mais fácil se ele estiver em um repositório separado.
Então, no seu caso, parece que o layout que você esboçou acima seria razoável, como você compartilhou o código e deseja que ramos / tags incluam esse código compartilhado.
Sua descrição do uso de tags e ramificações eminentemente sensível e é como eu esperaria que o svn fosse usado. Essa é realmente a intenção de marcar como eu entendo. BTW em svn tags e branches são na verdade a mesma coisa, mas a terminologia é aplicada conforme você aplicou.
Pessoalmente, também adicionei a ressalva de que qualquer coisa comprometida com o tronco deve ser construída, deve ser atômica e não deve quebrar qualquer teste de unidade. Os ramos são para trabalhos inacabados em andamento. Espero que o tronco seja um potencial candidato a liberação em qualquer ponto.
O seguinte é a melhor forma de estabelecer um repositório do Subversion.
Desta forma, você pode verificar projetos individuais por si só.
Se você deseja verificar todos os 3 projetos e fazer uma compilação unificada com algum script / sistema de compilação monolítico, então investigue usando um módulo mestre com svn: mapeamento externo de todos os outros projetos no tronco mestre.
Isso é mais complicado à primeira vista, mas é a maneira mais sustentável e idiomática de resolver esse problema com o Subversion.

Estratégia de controle de versão svn
Obter através da App Store Leia esta publicação em nosso aplicativo!
Práticas recomendadas CVS / SVN para ramificação e marcação.
Eu serei responsável por decidir como a correção de marcação vai acontecer no nosso reporte CVS / SVN.
Existe alguma literatura que me ajude a entender a melhor maneira de trabalhar com CVS? ou ramificação / marcação, etc?
13 Respostas.
Minha experiência pessoal durante mais de 10 anos de CVS no projeto FreeBSD é: mudar para outra coisa o mais rápido possível. O CVS está orientado a arquivos, não instantâneo / orientado para o conjunto de mudanças, o que faz a fusão entre agências bastante dolorosas. Os ramos são dolorosos com o CVS de qualquer maneira.
Quanto aos recursos para CVS, veja CVS Home.
Se você quiser falar sobre SVN, eu sugeriria o próprio Livro SVN e essa pergunta.
Ambos são excelentes recursos cheios de receitas que descrevem o que você quer fazer, em vez das descrições de nozes e parafusos da própria tecnologia nos livros anteriormente mencionados.
Eu recomendo SVN no Windows, Git no Linux. Não use o CVS, sim é terrível.
O Livro SVN é o que você precisa primeiro.
Marque cada compilação pública (lançamento). Branch é um tronco de cópia por algum motivo - e. outra forma de desenvolvimento. Repositório de filiais sempre que precisar :)
Eu acredito que isso é de codificação do horror:
O artigo de Chris Birmele sobre Branching and Merging é a melhor introdução que encontrei nesta tarefa de controle de origem essencial. Há dezenas de maneiras de se ramificar e nenhuma maneira correta de fazê-lo. Obtenha familiar com suas opções para que você saiba quais são as compensações com cada um.
Regras do polegar sensíveis:
Marque cada compilação (ou seja, cada compilação com um número de compilação - qualquer coisa que você possa enviar para testadores ou qualquer outra pessoa). Branch cada vez que você precisa se ramificar.
Normalmente, você precisa distribuir versões lançadas para que você possa testar e liberar patches. Você pode ter outros motivos para ramificação.
E você definitivamente está melhor com o Subversion.
As entradas posteriores no Source Control HOWTO da Eric Sink abrangem a ramificação e a fusão.
Se você quiser um iniciante para 10 para subversão:
Trate o "tronco" como uma história completa do seu desenvolvimento. Tudo que já é lançado deve aparecer no tronco em algum momento e de alguma forma.
Use ramificações de desenvolvimento (ramos do tronco) em tarefas de desenvolvimento complicadas. Quando a tarefa estiver concluída, use re-integrar a mesclagem para extrair as mudanças do ramo para o tronco. Desta forma, você tem alguns compromissos específicos para o tronco em vez de muitos comprometerem todos relacionados com a mesma tarefa. Elimine esses ramos de desenvolvimento quando não for mais necessário. Nomeie-os como 'FeatureX'
Use ramos de versão (novamente do tronco) para gerenciar as versões de marketing que estão destinadas a serem divulgadas aos clientes / implantadas para viver. Uma versão é um subconjunto das revisões no tronco. Para usá-los, ramo do tronco em uma revisão apropriada (pode não ser cabeça), registre manualmente as revisões do tronco como sendo incorporadas nesse ramo, junte-se em todas as revisões adicionais que você precisa do tronco (somente do tronco). Não se desenvolva diretamente em um ramo de versão, apenas se fundem no tronco - embora a mesclagem possa precisar de trabalho extra para torná-lo compatível com a versão. Nome como 'Versão 2.4'
Crie tags específicas de seus ramos de versão sempre que você fizer uma compilação ou um hotfix que seja lançado aos clientes ou implantado em live. Nome como '2.4.1', '2.4.2' etc.
Trabalhando desta forma, você pode usar o rastreamento de mesclagem do subversion (versão 1.5 e acima) para ver exatamente o que está em cada tag em uma revisão por revisão. Para fazer isso, obtenha uma cópia de trabalho de sua tag ou ramo de versão e faça 'svn mergeinfo --show-revs mesclado svn / tronco c: \ workingcopy \'
Isso é ótimo para auditores, notas de versão geradas automaticamente, testadores e sua própria confiança sobre exatamente o que está acontecendo e o que está fora. Use uma matriz gerada automaticamente com esta informação para ver de relance o que as diferentes versões possuem.
você deve deixar CVS. O CVS é ​​antigo e não muito rápido em termos de ramificação / marcação (a criação de ramo / tag depende linearmente do número de arquivos em um projeto)
Você deve pensar primeiramente em sua estratégia de ramificação: você quer ter uma.
ramo de tronco estável ramificações sucursais do desenvolvedor troncos instáveis ​​/ ramos de plataforma de ramos de liberação.
Isso depende fortemente de sua filosofia de projeto e desenvolvimento.
Se você deseja usar o SVN, você realmente deve pensar no layout do seu repositório, porque quase todos os softwares são baseados em módulos e você deve encontrar uma estrutura na qual você pode facilmente marcar todos os módulos necessários. O SVN com sua abordagem baseada em pastas de ramos / tags não é fácil de alcançar esse requisito.
Isso dizia que deveria ficar claro, que os layouts multidispositivos são mais difíceis de manter um sistema de marcação estável. Eu prefiro uma abordagem "tag all", no entanto, esta é a minha escolha pessoal.
Ao ir para o meu primeiro SCM real (da fonte segura) há anos atrás, achei o seguinte útil - naquela época, havia um documento técnico, perforce, penso:
O Cederqvist geralmente é considerado o guia do CVS.
Eu recomendaria usar o GIT, pois o processo de marcação / ramificação é extremamente fácil de usar. O benefício de usar o SVN (especialmente no Windows) é o número de ferramentas GUI e a integração do shell do Windows.
Eu tambem em segundo lugar a recomendação para os livros Pragmatic Programmer no SVN.
Bem, isso realmente não importa o sistema de controle de origem que você usa, todos basicamente seguem alguma estrutura de tronco / ramos / tags. Mesmo que seja um modelo distribuído, os repositórios serão configurados de forma a refletir isso.
Existe uma explicação muito simples para você começar aqui.

Estratégia de controle de versão svn
Obter através da App Store Leia esta publicação em nosso aplicativo!
Como usar SVN, Branch? Tag? Tronco?
Eu estava googleando um pouco e não consegui encontrar um bom guia "iniciantes" para SVN, não no sentido de "como eu uso os comandos" em vez disso; Como controlo meu código fonte?
O que eu gostaria de esclarecer é o seguinte:
Com que frequência você comete? Tão frequentemente quanto se pressionaria Ctrl + s? O que é um ramo e o que é uma etiqueta e como você os controla? O que se passa no SVN? Somente código fonte ou você compartilha outros arquivos aqui também? (Não foram considerados arquivos versionados ..)
Eu não tenho idéia do que ramo e tag é para que eu não conheça o propósito, mas meu palpite é que você carrega coisas no porta-malas e quando você faz uma grande compilação, você a move para o ramo? Então, o que é considerado uma grande construção neste caso?
16 Respostas.
O livro de subversão é uma excelente fonte de informações sobre estratégias para arquivar seu repositório, ramificação e etiquetagem.
Perguntei-me as mesmas perguntas quando chegamos a implementar o Subversion aqui - cerca de 20 desenvolvedores espalhados por 4 a 6 projetos. Não encontrei nenhuma boa fonte com '' a resposta ''. Aqui estão algumas partes de como nossa resposta se desenvolveu nos últimos 3 anos:
- cometer sempre que é útil; nossa regra geral é comprometer sempre que você fez um trabalho suficiente que seria um problema ter que re-fazer se as modificações se perderam; às vezes eu começo a cada 15 minutos ou mais, outras vezes pode ser dias (sim, às vezes me demora um dia para escrever 1 linha de código)
- usamos ramos, como sugeriu uma de suas respostas anteriores, para diferentes caminhos de desenvolvimento; Agora, para um de nossos programas, temos 3 ramos ativos: 1 para o desenvolvimento principal, 1 para o esforço ainda inacabado para paralelizar o programa e 1 para o esforço de revisá-lo para usar arquivos de entrada e saída XML;
- dificilmente usamos tags, embora pensemos que deveríamos usá-las para identificar lançamentos para a produção;
Pense no desenvolvimento em um único caminho. Em algum momento ou o estado do marketing de desenvolvimento decide lançar a primeira versão do produto, então você planta uma bandeira no caminho rotulado '1' (ou '1.0' ou o que você tem). Em algum outro momento, uma lâmpada brilhante decide paralelizar o programa, mas decide que isso levará semanas e que as pessoas querem seguir o caminho principal enquanto isso. Então, você constrói um garfo no caminho e diferentes pessoas vagam pelas diferentes garfo.
As bandeiras na estrada são chamadas de "tags", e os garfos na estrada são onde os "ramos" se dividem. Ocasionalmente, também os ramos voltam juntos.
- colocamos todo o material necessário para construir um executável (ou sistema) no repositório; Isso significa, pelo menos, código fonte e criar arquivo (ou arquivos de projeto para o Visual Studio). Mas quando temos ícones e arquivos de configuração e todas essas outras coisas, isso vai para o repositório. Alguma documentação encontra o caminho para o repo; Certamente, qualquer documentação, como arquivos de ajuda que possam ser integrantes do programa, é um lugar útil para colocar a documentação do desenvolvedor.
Nós até colocamos executáveis ​​do Windows para nossos lançamentos de produção lá, para fornecer um único local para pessoas que procuram software - nossos lançamentos de Linux vão para um servidor, portanto, não precisam ser armazenados.
- não exigimos que o repositório seja sempre capaz de entregar uma versão mais recente que seja compilada e executada; Alguns projetos funcionam desse jeito, outros não; A decisão recai sobre o gerente do projeto e depende de muitos fatores, mas acho que isso ocorre quando faz grandes mudanças em um programa.
O mais frequente possível. O código não existe a menos que esteja sob controle de origem :)
Compromissos frequentes (depois pequenos conjuntos de mudanças) permitem que você integre suas mudanças facilmente e aumente as chances de não quebrar algo.
Outras pessoas observaram que você deveria comprometer-se quando você tiver um código funcional, no entanto, acho útil se comprometer com um pouco mais de frequência. Poucas vezes eu percebi que eu uso o controle de origem como um mecanismo rápido de desfazer / refazer.
Quando eu trabalho no meu próprio ramo, eu prefiro comprometer o máximo possível (literalmente, sempre que pressiono ctrl + s).
Leia o livro SVN - é um lugar que você deve começar quando aprende SVN:
Documentação, pequenos binários necessários para a compilação e outras coisas que têm algum valor para o controle de origem.
Aqui estão alguns recursos sobre frequência de confirmação, mensagens de compromisso, estrutura do projeto, o que colocar sob controle de origem e outras diretrizes gerais:
Essas perguntas sobre o estouro de pilha também contêm algumas informações úteis que podem ser de interesse:
Quanto aos conceitos básicos do Subversion, como ramificação e marcação, acho que isso é muito bem explicado no livro do Subversion.
Como você pode perceber depois de ler um pouco mais sobre o assunto, as opiniões das pessoas sobre o que é melhor prática nesta área geralmente variam e às vezes são conflitantes. Eu acho que a melhor opção para você é ler sobre o que outras pessoas estão fazendo e escolher as diretrizes e práticas que você sente são mais sensíveis para você.
Eu não acho que seja uma boa idéia adotar uma prática se você não entende o propósito dela ou não concorda com a lógica por trás disso. Portanto, não siga nenhum conselho cegamente, mas sim faça sua própria opinião sobre o que você acha que vai funcionar melhor para você. Além disso, experimentar com diferentes maneiras de fazer as coisas é uma boa maneira de aprender e descobrir como você mais gosta de trabalhar. Um bom exemplo disso é como você estrutura o repositório. Não há nenhuma maneira correta ou errada de fazê-lo, e muitas vezes é difícil saber qual a maneira que você prefere até que você realmente as tenha experimentado na prática.
A frequência de compromisso depende do seu estilo de gerenciamento de projetos. Muitas pessoas se abstêm de comprometer se vai quebrar a compilação (ou funcionalidade).
Os ramos podem ser usados ​​de duas maneiras, normalmente: 1) Um ramo ativo para o desenvolvimento (e o tronco fica estável), ou 2) ramos para caminhos de dev. Alternativos.
As tags geralmente são usadas para identificar lançamentos, para que eles não se percam na mistura. A definição de "liberação" depende de você.
Eu acho que o principal problema é a imagem mental do controle de origem é confundida. Costumamos ter troncos e ramos, mas depois temos idéias não relacionadas de tags / lançamentos ou algo a isso afeta.
Se você usar a idéia de uma árvore mais completamente, fica mais claro, pelo menos para mim.
Nós conseguimos o tronco -> formas de ramos -> produzem frutas (tags / lançamentos).
A idéia é que você cresça o projeto de um tronco, o que então cria ramos uma vez que o tronco é estável o suficiente para segurar o ramo. Então, quando o ramo produziu uma fruta, você a retira do ramo e solte-o como uma etiqueta.
As tags são essencialmente entregáveis. Enquanto o tronco e os ramos os produzem.
Como outros disseram, o Livro SVN é o melhor lugar para começar e uma ótima referência uma vez que você tenha obtido as pernas do mar. Agora, para suas perguntas.
Com que frequência você comete? Tão frequentemente quanto alguém pressionaria ctrl + s?
Muitas vezes, mas não sempre que pressiona ctrl + s. É uma questão de gosto pessoal e / ou política de equipe. Pessoalmente, eu diria que começo quando você completar um código funcional, por mais pequeno que seja.
O que é um ramo e o que é uma etiqueta e como você os controla?
Primeiro, o tronco é onde você faz seu desenvolvimento ativo. É a linha principal do seu código. Um ramo é algum desvio da linha principal. Pode ser um grande desvio, como uma versão anterior, ou apenas um menor ajuste que você deseja experimentar. Uma tag é um instantâneo do seu código. É uma maneira de anexar um rótulo ou marcador para uma revisão específica.
Vale ressaltar que em subversão, tronco, ramos e tags são apenas convenções. Nada o impede de fazer trabalhos nas tags ou ter filiais que são sua linha principal, ou desconsiderar o esquema tag-branch-trunk juntos. Mas, a menos que você tenha uma razão muito boa, é melhor ficar com a convenção.
O que se passa no SVN? Somente código fonte ou você compartilha outros arquivos aqui também?
Também uma escolha pessoal ou de equipe. Eu prefiro manter qualquer coisa relacionada à compilação no meu repositório. Isso inclui arquivos de configuração, scripts de compilação, arquivos de mídia relacionados, documentos, etc. Você não deve verificar os arquivos que precisam ser diferentes na máquina de cada desenvolvedor. Nem você precisa verificar os subprodutos do seu código. Estou pensando principalmente em pastas de compilação, arquivos de objeto e similares.
Eric Sink, que apareceu no SO podcast # 36 em janeiro de 2009, escreveu uma excelente série de artigos sob o título Source Control How-to.
(Eric é o fundador da SourceGear que comercializa uma versão plug-compatible do SourceSafe, mas sem a horribilidade.)
Apenas para adicionar outro conjunto de respostas:
Eu começo sempre que eu terminar um trabalho. Às vezes, é um pequeno bugfix que acabou de mudar uma linha e me levou 2 minutos para fazer; outras vezes é duas semanas de suor. Além disso, como regra geral, você não comete nada que quebre a compilação. Assim, se você demorou muito para fazer alguma coisa, pegue a versão mais recente antes de confirmar, e veja se suas alterações quebram a compilação. Claro, se eu passar muito tempo sem cometer, isso me deixa desconfortável porque não quero perder esse trabalho. Em TFS eu uso essa coisa legal como "prateleiras" para isso. No SVN, você terá que trabalhar de outra forma. Talvez crie seu próprio ramo ou faça backup desses arquivos manualmente em outra máquina. Os ramos são cópias de todo o projeto. A melhor ilustração para seu uso é talvez a versão de produtos. Imagine que você está trabalhando em um grande projeto (digamos, o kernel do Linux). Depois de meses de suor, você finalmente chegou à versão 1.0 que você divulgou ao público. Depois disso, você começa a trabalhar na versão 2.0 do seu produto, que será melhor. Mas, entretanto, também há muitas pessoas que estão usando a versão 1.0. E essas pessoas acham erros que você precisa consertar. Agora, você não pode corrigir o erro na próxima versão 2.0 e enviar isso para os clientes - não está pronto. Em vez disso, você precisa retirar uma cópia antiga da fonte 1.0, corrigir o erro lá e enviar isso para as pessoas. É para isso que são os ramos. Quando você lançou a versão 1.0, você criou uma filial no SVN, que fez uma cópia do código-fonte nesse ponto. Esse ramo foi chamado "1.0". Você continuou a trabalhar na próxima versão em sua cópia principal, mas a cópia 1.0 permaneceu lá como estava no momento do lançamento. E você pode continuar corrigindo erros lá. As tags são apenas nomes anexados a revisões específicas para facilidade de uso. Você poderia dizer "Revisão 2342 do código fonte", mas é mais fácil se referir a ele como "Primeira revisão estável". :) Costumo colocar tudo no controle de origem que se relaciona diretamente com a programação. Por exemplo, desde que estou fazendo páginas da web, eu também coloco imagens e arquivos CSS no controle de origem, para não mencionar arquivos de configuração etc. A documentação do projeto não entra, no entanto, isso é realmente apenas uma questão de preferência.
Outros afirmam que depende do seu estilo.
A grande questão para você é com que frequência você "integra" seu software. O desenvolvimento orientado por teste, Agile e Scrum (e muitos, muitos outros) dependem de pequenas mudanças e integração contínua. Eles pregam que pequenas mudanças são feitas, todos acham as pausas e as consertam o tempo todo.
No entanto, em um projeto maior (pense em governo, defesa, 100k + LOC), você simplesmente não pode usar a integração contínua, pois não é possível. Nessas situações, pode ser melhor usar ramificações para fazer muitos pequenos compromissos, mas trazer de volta ao porta-malas SOMENTE, o que funcionará e estará pronto para ser integrado na compilação.
Uma ressalva com ramificação é que, se eles não são gerenciados corretamente, pode ser um pesadelo em seu repositório para conseguir o trabalho no tronco, como todos estão se desenvolvendo a partir de diferentes pontos do tronco (o que é incidentalmente um dos maiores argumentos para integração contínua).
Não há uma resposta definitiva sobre esta questão, a melhor maneira é trabalhar com sua equipe para encontrar a melhor solução de compromisso.
Controle de versão com Subversion é o guia para iniciantes e mãos antigas.
Eu não acho que você pode usar Subversion efetivamente sem ler, pelo menos, os primeiros capítulos deste.
Para cometer, uso as seguintes estratégias:
comprometer-se sempre que possível.
Cada alteração de recurso / bugfix deve ter seu próprio commit (não cometer muitos arquivos de uma só vez, pois isso fará com que o histórico desse arquivo não seja claro - por exemplo, se eu alterar um módulo de log e um módulo GUI de forma independente e comprometo ambos de uma só vez, ambas as mudanças serão visíveis em ambos os históricos de arquivos. Isso dificulta a leitura de um histórico de arquivos),
não quebre a compilação em qualquer commit - deve ser possível recuperar qualquer versão do repositório e construí-la.
Todos os arquivos necessários para criar e executar o aplicativo devem estar no SVN. Os arquivos de teste e tal não devem, a menos que façam parte dos testes unitários.
Muitos bons comentários aqui, mas algo que não foi mencionado é enviar mensagens. Estes devem ser obrigatórios e significativos. Especialmente com ramificação / fusão. Isso permitirá que você acompanhe quais mudanças são relevantes para quais recursos de bugs.
por exemplo svn commit. - m 'bug # 201 corrigiu o erro y2k no código' dirá a qualquer um que olhe para o histórico para o qual foi essa revisão.
Alguns sistemas de rastreamento de erros (por exemplo, trac) podem procurar no repositório dessas mensagens e associá-las aos tickets. O que facilita a elaboração de mudanças que estão associadas a cada bilhete.
A política em nosso trabalho é assim (equipe multi-desenvolvedora trabalhando em framework orientado a objetos):
Atualize a partir do SVN todos os dias para obter as alterações do dia anterior.
Comece diariamente, então, se você está doente ou ausente no próximo dia (s), alguém pode facilmente assumir o controle de onde você parou.
Não cometer código que quebre qualquer coisa, pois isso afetará os outros desenvolvedores.
Trabalhe em pequenos pedaços e comece diariamente COM COMENTÁRIOS SIGNIFICATIVOS!
Como uma equipe: Mantenha um ramo de Desenvolvimento, então mova o código de pré-lançamento (para QA) em um ramo de Produção. Este ramo deve ter apenas um código de trabalho completo.
O Manual TortoiseSVN TSVN é baseado no livro de subversão, mas disponível em muitos mais idiomas.
Eu acho que há duas maneiras de cometer freqüência:
Cometer com frequência, para cada método implementado, pequena parte do código, etc. Comprometer apenas as partes completas do código, como módulos, etc.
Eu prefiro o primeiro - porque usar o sistema de controle de origem é muito útil não só para o projeto ou empresa, o primeiro de tudo é útil para o desenvolvedor. Para mim, o melhor recurso é reverter todo o código ao procurar a melhor implementação da tarefa atribuída.

SVN, Git Fora daqui: como escolher o seu sistema de controle de versão.
Nos últimos anos, o uso do Git aumentou enormemente popularizando sistemas de controle de versão distribuídos. De acordo com uma pesquisa da comunidade Eclipse, em 2018, o Git finalmente superou o SVN como um Sistema de Controle de Versão (VCS) de escolha para desenvolvedores Java.
As plataformas de hospedagem, como o GitHub e o Bitbucket, possibilitaram o controle de versão distribuída, proporcionando à comunidade de desenvolvimento o espaço e as ferramentas de hospedagem. A Microsoft fez do Git o provedor de controle de versão padrão para novos projetos em sua plataforma TFS e encoraja fortemente os desenvolvedores a usar o Git, a menos que precisem especificamente de um VCS centralizado. Então, como o VCS mais popular compara sua implementação de modelos de ramal de características e seu nível de conveniência?
Selecionando um Sistema de Controle de Versão para Ajustar Suas Necessidades.
Quando uma equipe começa um novo projeto ou atinge um ponto de inflexão em uma iniciativa em andamento, oferece a oportunidade de perguntar: "O meu sistema de controle de versão atual funciona?" "Quais são as diferenças entre o Git e o SVN?" Vamos explorar três dos os sistemas de controle de versão mais populares - Git, SVN e Mercurial. Do ponto de vista ideológico, Mercurial e Git se enquadram na mesma categoria de VCS distribuído. Quais são as principais diferenças e por que escolhemos o Git?
Sistemas de controle de versão distribuídos vs. centralizados.
Primeiro veio o sistema de controle de versão centralizado com RCS (1982) e seu sucessor CVS (1987). Atualmente, os mais populares são Subversion, TFVC, Perforce e Clearcase. Usando esses sistemas, todos os desenvolvedores acessam um único repositório central. Se uma mudança for feita, ele alcançará todos os desenvolvedores antes que eles possam comprometer suas alterações e, infelizmente, isso também inclui código quebrado. Uma vez que existe apenas um repositório "verdadeiro", o trabalho offline pode ser um desafio. Para completar as operações básicas, como adicionar o histórico de visualização ou código de compromisso, você precisa acessar o repositório.
Um dos primeiros sistemas de controle de versão distribuídos foi Bitkeeper (1997). As ferramentas populares atuais incluem Git, GNU Arch e Mercurial. No modelo distribuído, cada desenvolvedor possui sua própria cópia do repositório. Usando essa abordagem, os desenvolvedores podem trabalhar offline - eles podem comprometer, filmar, mesclar filiais, visualizar o histórico, tudo o que eles precisam, pois eles têm todo o repositório em mãos. O acesso à Internet é necessário somente quando a sincronização com os outros membros da equipe ocorre.
Diferenças entre Mercurial e Git.
Existem duas grandes diferenças entre Mercurial e Git.
Monólito. Mercurial vem como um aplicativo monolítico, enquanto que Git, seguindo a ideologia linux, vem como uma série de binários pequenos que muitas vezes permanecem escondidos para o desenvolvedor. Ter as ferramentas finas para poder ajustar o sistema significa que o Git é extremamente flexível. Precisão e flexibilidade são importantes para os clientes. Então, ter a flexibilidade para implementar soluções não padronizadas pode ser um trocador de jogos.
História. A outra diferença entre Mercurial e Git é como eles lidam com a história. O Git permite que (e alguns possam dizer incentivar) os usuários a reescrever o histórico de seu repositório quando quiserem. Isso permite que os logs de confirmação sejam cuidadosamente ajustados para manter o log simples e logicamente estruturado, em vez de englobar todo o histórico, como aconteceu. Com grande poder vem grande responsabilidade, então as reescritas de histórico devem acontecer apenas em compromissos locais.
No final, ambos os sistemas são muito semelhantes. Além disso, muitos dos recursos que o Git fornece fora da caixa são trazidos para o Mercurial como plugins. O fluxo de trabalho do ramo de recursos pode ser implementado facilmente tanto no Git como no Mercurial.
Prós e contras, implementando o processo de desenvolvimento do ramo de recursos com o Git.
A ramificação no VCS nos permite criar uma cópia virtual do código para fazer alterações sem afetar o código original. No modelo de ramal de recursos, queremos ter um ramo separado para cada nova característica. Existem vários benefícios importantes para isso.
Pro: comentários fáceis de código antes do código de mesclagem.
As revisões de código são excelentes. Eles ajudam a manter o código uniforme, mantendo o mesmo estilo e reduzindo significativamente a necessidade de refatoração para colocar o código em alinhamento com os padrões. Ocasionalmente, as revisões de código também podem capturar erros mesmo antes que o problema seja transferido para um analista de garantia de qualidade, economizando um tempo precioso durante o processo de desenvolvimento.
Pro: melhor controle sobre a fonte.
O que torna a abordagem do pedido de recursos tão popular é o isolamento que ele fornece. As características são incubadas separadamente do código e não afetam a base de código antes de estarem prontas. Embora o SVN forneça ramificação, os ramos temporários são usados ​​apenas para recursos maiores devido ao seu preço em grandes projetos.
Pro: transição fácil entre questões.
Muitas vezes, os desenvolvedores precisarão pausar e articular o trabalho entre diferentes problemas ou tarefas durante o processo. Suponha que um desenvolvedor tenha trabalhado em um problema há aproximadamente uma semana quando uma nova correção crítica é necessária na produção. Claro, ele pode fazer um patch SVN ou fazer um download limpo do código-fonte em uma nova localização, mas essas soluções alternativas irão custar o tempo e causar frustrações. Usando o fluxo de trabalho de ramificação por recurso, todo esse trabalho pode ser feito com um commit temporário simples e uma mudança de ramificação.
Pro: processo de melhor liberação.
Os ramos de recursos se alinham perfeitamente com o popular Git Flow. Ele é responsável por todos os cenários possíveis, como hotfixes, congelamento de código e outros.
Con: registro de histórico complexo.
Quanto aos contras, eles vêm das etapas adicionais que os desenvolvedores devem completar. Os desenvolvedores devem certificar-se de que eles se ramificam do commit direito. Dependendo da estratégia de mesclagem para os problemas concluídos, o log de histórico pode tornar-se maior e mais difícil de entender.
Diferenças entre Git e SVN.
Uma das diferenças mais notáveis ​​ao mudar para Git é a sua velocidade. Uma vez que todo o repositório é armazenado localmente na máquina do desenvolvedor, ele ou ela pode trabalhar por dias com uma conexão de internet muito fraca. Criar ramos é relâmpago devido à implementação da filial do Git. No Git, um ramo é simplesmente uma referência a um commit, onde serão anexados os seguintes compromissos. Não contém nem informações básicas como criar data, usuário que a criou ou algum tipo de mensagem.
Como o Git incentiva o uso de agências, não podemos esquecer de dar um grito às suas capacidades de mesclagem. O SVN antes da versão 1.5 apenas fez mesclagens bidirecionais envolvendo um conjunto de alterações aplicado à base de código atual, porque não armazenava informações de mesclagem. Git uses the history of the repository to identify the common base between the merged branches and only needs to merge from where they diverged — thereby completing a three-way merge. SVN is also improving and has supported three-way merging since 1.5. In the upcoming 1.9 version of SVN, it will also have better rename/move tracking of files, something that Git already does.
Integration with Other Software.
SVN has operated for over 15 years and thanks to its popularity has been integrated on most of today’s integration servers, issue tracking systems, IDEs and others. When considering the differences between Git and SVN, despite being 5 years younger than SVN, Git is by no means behind. It’s easy to integrate it with other software. Git itself provides only command line tools, but many companies have created various UI on top of it like Atlassian’s SourceTree, Github, Git Extensions and others.
Adopting Git.
When weighing the differences between Git and SVN, Git offers few cons. Among them is the slightly steeper learning curve, at least in the beginning. If the developers on a project have worked only with centralized VCS, they may face some slowdowns navigating some of the differences, like the synchronization process and the added staging step when creating a commit. As mentioned, there are many GUI applications that can make the life of a developer easier and, if needed, they also provide command line interface in case more advanced commands are needed.
Not ready to switch to a Git repository yet, but still want to use a feature branch approach?
Git provides a tool called git-svn, which allows tracking a standard Subversion repository and provides a bidirectional flow of changes between them. You have the ability to work with feature branches and synchronize with the SVN repo’s branches when you need to. All this does not impact the team whatsoever as only the developer knows he is using a Git repository locally. Microsoft have adopted a similar approach with TFS. They have provided a git-tf tool which enables the ability to track a TFS repository. However in this way, the feature branch model is not utilized to its full potential as the management of the project cannot benefit from it.
Feature branches provide isolation and convenience. Thanks to the internal implementation of Git, creating branches — one of the expensive operations in SVN — is basically “free of charge.” This allows for instantaneous creation and cleanup of the temporary branches for creating new features.
Innovate with us. Click here to access all of our free resources.
Ao bater palmas mais ou menos, você pode nos indicar quais são as histórias que realmente se destacam.

Backblaze and Subversion, Time to Change?
Our recent post on Source Code Control led many to ask, what does Backblaze use? The short answer is Subversion (SVN). The longer questions are: why did we pick it, how has it worked out, and should we switch?
What Most Companies Use for Version Control.
According to the folks at Duck Software Open Hub (formerly Ohloh), Backblaze is not alone in using SVN; in fact, SVN is still the most popular repository among the registered Open Hub users as you can see in the chart below:
Backblaze has used Subversion since we started in 2007. It was selected and set up by Brian Wilson, our CTO. On his personal blog, Brian, documented his experience in getting Subversion up and running for Backblaze. Some of the article specifics are a bit outdated as the server used was running Windows Server 2003, but the overall process still works. As a side note, the Dell Optiplex server Brian used was only recently retired from service.
Brian chose SVN for Backblaze even though he had not used SVN before. Previously he had worked with Perforce and CVS. Using Perforce was out because we would have to pay for the licenses and when you are bootstrapping a company from your own pocket, such things are luxuries. He asked around and several of his friends suggested SVN. In mid-2007, SVN was becoming well known in the developer community, while CVS seemed to be languishing. In hindsight either choice probably would have worked for Backblaze, but Brian went with SVN and never looked back.
Brian installed and used SVN even though at the time he was the only engineer. Por quê? Rule #1 of Brian’s 10 Rules for how to write cross-platform code, “Simultaneously develop – don’t port.” He would write code initially on his PC, check it into Subversion, and then check it on his Mac to make sure it worked. This allowed him to quickly develop our cross-platform “base” libraries (Rule #5) that we continue to use today.
Our Experience Running Subversion.
As Backblaze has grown since 2007, not only have we added more engineers to Subversion, but we’ve also had more departments get on board. Today, our tree manages contributions from engineering, operations, web development and even marketing. Subversion has been a good fit for Backblaze as we are fairly linear in our development practices. We rarely (if ever) branch our code, instead adding things in a continuous fashion. That’s not as crazy as it seems, as noted by Martin Fowler, a self-described champion of continuous integration:
“Subversion encourages a simple central repository model, discouraging large scale branching. In an environment that’s using Continuous Integration, which is how most of my friends like to work, that model fits reasonably well. As a result Subversion is a good choice for most environments.”
I polled some of the engineers at Backblaze to get their sense as to whether they’d consider changing from Subversion. There was some enthusiasm for moving to GIT and a couple of votes for Mercurial, but the most prevalent sentiment was “if it ain’t broke, don’t fix it.” There was also a realization that at some point change could be inevitable as the team continued to grow in size and product continued to increase in scope, but right now the team can still “Grok” the system using SVN.
Would You Switch from Subversion?
On the Stack Exchange network there is a great discussion on why someone might consider changing from Subversion and consider another system (mostly GIT or Mercurial in this case): programmers. stackexchange/questions/35074/im-a-subversion-geek-why-should-i-consider-or-not-consider-mercurial-or-git-or. The discussion is a couple of years old, but still worth reviewing. In addition, the discussion includes references to other resources worth reading as well.
For the moment Backblaze is sticking by Subversion, but just for fun let’s make you the Backblaze CTO. As CTO, you are charged with looking into your crystal ball to determine what we should do over the next couple of years. Below are a handful of high-level requirements to get you started.
The version control system should be open-source, but reasonably well supported by the community. We don’t branch very much today, not because it’s hard with SVN, but because we don’t need to branch very much. We have well defined teams for the mac client, windows client, server functions, operations, and mobile services. Code check-in conflicts do not occur very often and when they do they are mostly obvious and easy to solve. About 10% of our engineering group lives and works out of state, visiting our headquarters in San Mateo once a month or so. We have non-engineers (i. e. marketing and operations) using SVN today.
Based on your experience, what other things should we be considering? What source code control system do you use? Why did you choose that one? Is it everything you thought it would be? We’d love to hear your thoughts.
Andy Klein.
Latest posts by Andy Klein (see all)
Cloud Babble: The Jargon of Cloud Storage - January 18, 2018 What is HAMR and How Does It Enable the High-Capacity Needs of the Future? - December 14, 2017 B2 Cloud Storage Roundup - November 9, 2017 Hard Drive Stats for Q3 2017 - October 26, 2017 Yes, Backblaze Just Ordered 100 Petabytes of Hard Drives - October 5, 2017.
You don’t need to force anyone to change their ways, to be honest. If I was working for you guys though, I’d be using git svn on the sly :-) And you’d never know it!
Useful blog post . For what it’s worth , if someone are looking for a service to merge PDF files , my business found a tool here ALTO-Merge.
My focus on high assurance systems keeps me on security-enabling, centralized designs like hardened Subversion, Aegis, etc. So I avoid DVCS. Similarly, you might not need it but they’re right that you should try it: lets you start getting long-term ROI out of a potentially better development flow and lower SCM-related risks. However, I’d recommend Mercurial over Git because Git has serious design issues:
Not sure if any of these have been fixed since. Yet, seeing flaws of this sort make me not want to waste time on a tool where developers didn’t invest time into making it comprehensible, consistent, and safe. Tools shouldn’t get in their users’ way, imho. Previous SCM systems I used didn’t. Git does. Mercurial not so much, although DVCS to VCS is still a learning curve. So, I’d say start with Mercurial and switch to Git only if you need its advanced features.
My take on the SVN vs Git is simple. Software development is all about cycles within cycles. Por exemplo. write a change, compile, test change, repeat. In the SVN scenario you’re tied to performing many of these change cycles before you can commit your changes. The act of committing and sharing software with your team are tightly coupled. In the git mindset, these two things are seperate. This separation allows you see the software development activity as a continuous series of small bite sized experiments / changes, rather than a smaller amount of larger experiments.
“We don’t branch much…”. Realistically you do branch every time two people are working on copies of the master. Git just makes it more explicit (if you want).
My experience is running small-medium dev teams over the last decade+. During that time I’ve used Perforce, SVN (briefly), Mercurial and Git in roughly that sequence. I’ve always need basic branching support so that we can develop long-term new features alongside bug fixes to existing releases. My main conclusion would be to agree with the ‘it’s just source control’ argument. None of those SCM changes has had any significant impact on productivity, positive or negative. No change has ever recouped the time taken to rebuild our CI and release processes.
That said, I would view Subversion as something of a liability just because of its age and if it were my team I would be planning a move to Git at some point. It won’t open any magical doors or make you view software dev in a whole new light, but it will give you a modern, very actively supported toolset. I think the only requirement you have that argues against Git is the requirement for non-engineers to use it. I’m largely a command-line user and even simple operations can require the most arcane git commands. However, you can hide most of that behind the excellent Sourcetree UI from Atlassian and the overwhelming dominance of Git still gives it the edge over Mercurial for me. Finally I’d agree with the recommendations to go with BitBucket or GitHub for hosting; not needing to maintain and backup a server was the motivation for moving our last holdout project away from Perforce.
It’s funny to read the same things I used to say before switching :) Switching takes some time, also because Git is not super-user friendly. Having said that, I immediately saw benefits even as a solo developer!
One thing I would recommend is for the more curious of you to check out git-svn. It’s a bridge that lets you have a local git repository that communicates with a remote svn repository. It’s not incredibly polished, but it will let you benefit from: local commits, multiple local branches, reordering commits, etc. and I found it very useful to get familiar with git while still being a good citizen of an svn environment.
The strongest argument I have in favour of git is that I basically never ever heard from anyone that has made the switch who would like to go back. It’s just _that_ better.
Good luck with your new adventure!
I would like to think, right between Subversion and Bazaar, there is a single lone ‘1’ for Visual Sourcesafe. And that 1 would be me. (disclaimer: I use Git as well and will probably use AWS Code Repository going forward. I’m not sure if anything AWS appeals to those who DIY but Git is nice for the way it efficiently stores deltas)
I’ll just echo what other are saying that unless you’ve actually used a DVCS you probably aren’t gonna really understand the benefit. I first used version control back with RCS (pre-CVS/SVN/git/hg/etc/etc) and then on into CVS. The jump from CVS to SVN was an obvious one as CVS sucked in obvious ways that SVN fixed. I resisted DVCS for a long time since I also didn’t really see the benefit. Lots of new stuff to learn and the current tools I was using seemed to work fine for a paradigm that had served me well for 20+ years. I’m pretty conservative tech-wise as jumping on the latest fancy new thing is usually a mistake long-term. But Joel S. and others all swore DVCS was worth it so I took the plunge 2 years back and moved the main repository for our group from SVN to Git. The learning curve took a bit (highly recommend the free desktop GUI tools from Atlassian), but now that I’m living in Git I would never ever go back. I set up repositories even for personal projects where I’m the only developer. I commit many times a day and branch freely (often several time a day) and that’s just within my own local pile of code. It really changes the way you think about your code, reducing a mental load that I didn’t even realize was there that was holding me back from being as creative and aggressive about refactoring and doing things right without fear of ‘breaking that which already works’. Please try DVCS. Git’s the obvious choice simply because it’s got a larger market share and so it’s more likely new staff will already have the skills in hand when they come through the door. The differences between Git/Hg and the others are tiny compared to the move to DVCS in general.
It seems to be working for you.
I think it will take a long time to recoup even the small cost of switching and, assuming that your development efforts are planned and coordinated, you won’t see any substantial benefits or differences, particularly if everyone is doing continuous integration (as they should).
If the use of your SCM solution is a significant time / effort cost to your development effort, you need to fix the process and not the tool.
I used to be a big svn fan, and when I moved job, it hurt to find myself in a place still with cvs. Soon after though, we migrated to git, and now I’m totally sold. We use locally hosted Atlassian Stash (https://atlassian/software/stash) which gives us a feature-rich, GitHub-like environment.
To echo what others have said, the ability to switch with very low friction and use feature branches atomically is surprisingly useful when you get used to it. If my director comes along and says “stop that ticket, work on this super-urgent fix now”, I know that I can park what I’m doing and be confident that it won’t be epic trying to move there and back. We branch-per-ticket for all but the most trivial edits now, and it gives real clarity on who did what, why, and when.
The other key benefits for us, which haven’t been mentioned already, are really in the tooling. Stash (like GitHub) gives you pull requests. Even in a small team, the ability to conduct near-concurrent code review with inline commenting is fantastic for improving code quality. Sadly, it’s not a magic solution for finding bugs (good BDD/TDD practice is usually better for that), but it really helps ensure that what’s committed is clean, readable, and consistent with our code style. Especially when you set it to block merging until someone’s reviewed and approved it first :)
I personally also use SourceTree (sourcetreeapp – free!) which packages elegant visualisation of feature branches as well as a good diff/merge tool. Many other visual clients are available, and the CLI is all-powerful when you need it.
This is a meta-comment on this whole discussion. Speaking as someone who moved from using SVN to DVCS (both mercurial and git, though I have now standardized on git) a few years ago, I assert that you can’t understand the paradigm shift without actually diving in. How it was for me is that before I had a fair amount of hands-on experience with DVCS source control, I could not help trying to understand it from the perspective of what I already knew: SVN. But you just can’t get here from there.
It took working with mercurial and git enough to leave behind SVN conceptually before I could really understand how DVCS’s work and more importantly, how they change your coding workflow, massively and without question for the better.
From skimming through these comments, I’m pretty sure that Brian is in a similar place to where I was when contemplating switching. I don’t think any amount of explanation or argument is going to make much difference for him because without spending a good deal of time actually using a DVCS, I think he will keep looking at it from within the same source control paradigm that he is used to and just not see a compelling difference. It’s like trying to explain the color red to a blind man (no offense meant).
There was a comment below from Brian about it being “just source control”. That made me LOL because I could have, maybe even did, say the same thing. All I can say to you is having made the switch, I could never say that now.
5 reasons, coming from someone who has moved from subversion to git twice voluntarily:
1. Your working on some code, someone stops by your desk and says “hey, this is broken, can you help?” In subversion, a solid developer has a few second solution to have a clean repo. This is probably some tool they built themselves. Git stash comes on every developer’s box.
2. Are you on a plane without wifi? You aren’t going to be switching branches, checking history, or anything of the sort with subversion. You can do this just fine with Git. With subversion you have to log into the vpn just to get a decent log.
3. Merging isn’t just something you deal with when you are branching. Has someone committed while you were working locally? Resolving that means merging. Did two people commit in that time period? That’s an even messier merge. Git’s internals naturally resolve merges better than subversion. Sure, subversion has improved a lot over the last 5 years, but it still has a long way to go.
4. With git you have a full copy of your repo on every developer’s box. Heh, oh wait, you’re BackBlaze, I’m thinking the “infinite backups” arguments is less powerful there.
5. Git has rename tracking, I found that in Subversion I always regretted renaming things due to the history loss.
None of these things are a killer, they are just a bunch of tiny inconveniences. Why let those add up?
The funny thing is – when I read this article and the ending questions, my first thought was “I didn’t think this was still a question”. I thought DVCS and in particular git had “won” the source control world.
I agree with the other posters, you say branching isn’t a problem for you because you rarely do it, maybe you have got in the habit of rarely doing it because it’s a pain. Now you don’t notice the pain because (like Pavlov’s dogs) you’ve been conditioned out of doing it. If you move to git you’ll find it really easy so maybe it will become more of your workflow.
For example, at the last two places I’ve worked (including this one, where I introduced it), we have a script that runs in Jenkins as a job, that itself communicates with our git server, finds all the current branches and creates a CI job for them. Then it does a sweep to remove any CI jobs (matching a certain pattern) that are no longer branches. So developers can create branches any time they require, even if just for a few hours, know they are being checked by CI still and then remove the branch when it’s all merged and know that CI will blow its jobs away too.
I did find it very interesting that you quoted Martin Fowler on how Subversion is a good fit, when that article was written in 2018. 4 years is a LIFETIME in web terms. To bring things a bit more up to date:
“In recent years I’ve had more colleagues and friends write articles on my site using the toolchain. To work with them I set up a stripped down copy of my core website repo and we collaborate using **git**. *Since my collaborators are mostly programmers this workflow is pretty effective.*” & # 8212; martinfowler/articles/vagrant-chef-rbenv. html (4 September 2018)
Martin’s moved with the times, using Git, Chef, Vagrant, etc…
PLEASE focus on a Linux client. You can use SVN or Git or whatever you want for change control. I only care about our experience as end users, and I have been waiting for a Linux client forever :)
Related moreso to the post… SVN is definitely easier to grok. We have moved from SVN to Git, and lost some of our most advanced Git users, so there are some times that we wind up messing something up due to Git’s advanced capabilities. Ultimately I believe it is better than SVN, but you need to understand it enough before it becomes “better” & # 8211; otherwise it’s just a more complex way to do part of your core job.
I found git to be not as hard to grok as it appears to be. Good luck :)
I migrated our development team (flightaware) from CVS to git in 2018 and looking back I can confidently state that it was the single-most significant boost to our productivity and code quality that we’ve ever experienced. Moving to a distributed version control system that made branching and merging painless was transformative to our development pace, our release engineering process, and our developer happiness and job satisfaction. I’m still actively involved with a number of open source projects which still use SVN and whenever I have to interact with those codebases I feel sort of like I’m trying to type while wearing mittens. Thankfully, git acting as a front-end to SVN is well-exercised code and allows me to maintain some of my sanity. Everything Reefiest has said already rings very true to me, and I love the Spolsky article. I also think that it’s an hour well-spent to watch Linus’ talk to Google engineers: https://youtube/watch? v=4XpnKHJAok8 which I found very compelling.
& gt; single-most significant boost to our productivity and code quality.
Geez, it’s just source code control. I don’t really see how it could boost productivity or code quality. Heck, I suppose if it CORRUPTED files on checkin it could lower code quality? Developers shouldn’t be interacting with it more than a few minutes a day. Checkout in 30 seconds, spend 6 hours working furiously to edit files, compile, when finally ready testing for another few hours, checkin for 30 seconds writing a comment about what you did. Maybe every few months a problem occurs where we need to look through the checkin history.
Don’t discount the benefit of very granular commits and frequent merging. With git we’re able to branch and merge for specific feature development or speculative development in a way that CVS/SVN deters. This has resulted in better developer collaboration, better code documentation, and more effective debugging and regression testing. It’s also allowed us to move to a master/staging/production branch release infrastructure which yields better internal code testing and easier emergency code patching to production.
Most of our development takes place in feature branches now (single developers or teams) which are merged into a master development branch as appropriate. Each night the master branch is merged into a staging branch, which our employees use each day to internally test the code. Each night the staging branch is merged into production branch and deployed on our public web servers. Emergency changes committed to master can be “cherry picked” into staging or production or both if we need to bypass the release system.
It’s a robust workflow that has resulted in much better quality code which is better tested. Trying to do this sort of workflow with SVN or CVS would be impractical because of the branching and merging limitations discussed elsewhere in this thread. It has truly been a transformative switch for us and I can’t overstate how beneficial it’s been.
Plus the ability for teams of developers to collaborate in feature or bug fix branches without any drama has sped up our development pace even as we’ve grown the dev team. Tools that make it easier for developers to work together, share effort, and coordinate their individual activities are a direct boost to productivity.
& gt; Checkout in 30 seconds, *spend 6 hours working furiously to edit files*, compile, when finally ready testing for another few hours…
I’m sure this was just a dramatization and that you don’t believe that developers spend the great majority of their day “furiously editing files.” I know that you know the real work in building software is though-work. Though to be fair, most of the world, and many in the industry itself, seem to believe writing code to be the thing which takes the most time. :wink:
“We don’t branch very much (…) because we don’t need to branch very much.” & # 8211; that is something a SVN user would say: you said it yourself, you don’t think SVN is broken. But it is. Let me quote a good book on the subject, written by Joel Spolsky (the guy behind stackoverflow and trello). In the book he explains how to use Mercurial and there is a special chapter dedicated to people who used Subversion before:
“(…) if you’ve been using Subversion, your brain is a little bit, um, how can I say this politely? You’re brain damaged. No, that’s not polite. You need a little re-education. (…)”
This shocked me. I could not believe it myself, but a few chapters later, I realized the truth: I have been brai… uh… I needed re-education myself. Read the whole thing at hginit/00.html.
git blazingly-fast, feature-rich client can be used with a subversion repository. You do not need to switch the whole organization to git with all the pains that such migration might cause. Just tell the devs that it is okay to use the git client if they want to (with subversion as a central server for now) and then just… esperar.
+consider using github instead of hosting the server yourself. Mesmo.
Just the kind of info we’re looking for. We looked at Joel’s stuff, not sure we completely agree, but then again we’re using SVN so would we? Still “brain-damaged” I guess. Truth is we really don’t branch and don’t miss it. Still not sure where/when we are going, hence the reason for the post, appreciate the insights and the affirmation of the Spolsky POV.
Obrigado pelo feedback.
I can also recommend a git explanation by Linus Torvalds:
he addresses many points very relevant to your situation in this talk.
I used CVS for a while, then SVN, and now Git. I must agree with Reefiasty (and Spolsky), there are some fundamental differences that make Git not just a SVN alternative, but altogether a much better tool.
Sometimes something that isn’t broken needs to be upgraded to make life easier. You need Git, you just don’t know it. :)
& gt; because we don’t need to branch very much.” & # 8211; that is something a SVN user would say.
I think organizations of different sizes have different needs. When I was all alone at Backblaze, branching makes zero sense. But 25 years ago at the start of my career, I worked at Hewlett-Packard when they had more than 100,000 employees – and branching was very, very important to provide stability for releases.
It also matters your style of programming. I have personally always preferred to check in every day or as close to every day as possible. (Continuous Integration?) I try to do incremental changes that are self contained and still keep everything compiling and working well. But I understand some people like to avoid merging with the tree for months at a time, then to a massive merge. I think for those engineers they might gain more from something like GIT than I would.
When developers code for a full day without committing, do they ever have a moment when they think they may need to revert some of the recent changes to implement something in a different way? But then, from time to time, after Undo’ing it with ctrl+z and implementing the second version, it turns out that the first version was better, and now (since it is gone) it has to be written again. Alternatively one can be cautious enough to backup the modified files (manually or using some tool) before reverting them.
Now if those changes were all painlessly (and instantaneously: done before a spring in the keyboard has time to retract the enter key after it was clicked) saved in git, one could switch between them at will (with similar speed). One could revert or restore any portion of work which one quantified as a minimum quantifiable amount of work. Like IDE Undo, but across the whole source tree, with Redo capability and full memory of those (quantified) changes.
I tried to describe something svn is terrible at and git is good with, not sure if I got it right :)
As for hosting the git server yourself, three years ago I said almost the exact thing you just did (ok, 10GbE was not so popular back then). I can now only say that I regret not using github. They request a silly amount of money and everything just works OR one can pick and host a git server (gerrit was the best option for me at the time), but as with any software, one needs to get experienced with it to be able to fully manage it. That will take some time, which I truly expect to be of more value than the silly github plan price. Github adds issue tracker, code review, pull requests, API integration with external tools etc. There are open-source alternatives for all of those, but they will never integrate as well as github does and learning to host them will simply cost man hours. I believe that from a financial standpoint, hosting own git server is an expensive choice.
& gt; they think they may need to revert some of the recent changes to.
& gt; implement something in a different way?
It’s true, it has happened to me. :-) But personally I don’t like complicating the main “common” development path in order to support something that happens rarely. Most of the time I know I’ll like the fix and I implement it. More rarely I know it is a dodgy fix and I keep an old copy of the tree and avoid checking in until I’m 90 percent sure it’s the right direction. If it is the wrong direction I keep the changes moved aside on my local disk and start over with the original tree. AND THEN ONCE EVERY TWO YEARS I regret losing a section of code I wrote, then threw away.
But it’s just code, I can always rewrite it from scratch. If it really was that amazing, I probably stash it away in a file in the subversion server that isn’t part of the main compile, like “alternative_implememtation. txt”. Yes, these are all work arounds, but for me, the occasionally work around is fine. It doesn’t absolutely demand I get a different tool for the job. (Switching tools incurs a time penalty each time, it needs to save enough effort in the long run to deserve the pain of switching.)
Don’t get me wrong, GIT has a LOT of support in the world, and as time goes by and more and more people are familiar with GIT then it will become a fine choice of source code control. Backblaze would have survived fine on Perforce, on CVS, Subversion has been good to us, and Backblaze would survive fine switching to GIT, then switching again in three or four years as something new has gained traction.
The thing is, git doesn’t complicate. It simplifies. I understand the resistance to switching, especially as there is a small learning curve as you get used to the “git way” of doing things, but trust me when I say it makes your life way easier (even on single-developer projects).
“I have personally always preferred to check in every day or as close to every day as possible.”
Uau. Just, uh, wow. That’s terrifying to read. You really do have no idea what you’re missing with a git/mercurial distributed approach. With a good distributed revision control system you could be committing dozens of times throughout the day without impacting other developers. Having a more granular commit log makes it far easy to debug regression bugs, bisect to isolate specifically which code change introduced a bug, and change course during the development of a feature.
I know you said at the beginning that you don’t really have any use for branching, but you should realize that by withholding your commits all day long you are, in effect, branching — you just don’t call it that and your branch suffers from having no version control protections. It’s a de-facto branch you’re just doing it by hand in a tremendously sub-optimal way.
Imagine if your tools allowed you that flexibility with ease and without having to forego the benefits and safety of version control during your workday? Switch to git, give it a month to really gel, and you’ll come back to this post and be amazed at what you said here.
Waiting a whole day before making a commit is a MASSIVE MERGE. This is exactly the sort of brain damage that Joel is talking about. :)
I would recommend Gitlab (https://gitlab) for internal Git hosting. Then you host it yourself and get all the wonderful benefits of git.
I can’t recommend GitHub enough. Not because they’re a Git host – which they do very well – but because of all of the value-adds they layer atop Git.
Pull Requests are a HUGE boon for teams; the low barrier means code reviews can happen for every change to your system. The integrated social features (like @mentions, issues tracker, PRs, wiki, etc…) for talking about the what, why, where, and when of building products has been so very valuable to teams I’ve been a part of. They also support SSH and HTTP access to the code, making it super easy to set up. They have great GUI clients for Mac and Windows for non-technical folks who need to edit docs and such. Or they can even edit such things right from the web UI. And for any of your devs who are determined to stick with SVN, GitHub provides a Git SVN bridge (seriously!).
I’d also echo some of the other commenters’ posts re: dev practices of small, atomic commits, cheap branches, and things like rebasing, cherry-picks, bisect, etc… These are tools I use all the time. Tools I didn’t know I needed until I learned they existed.
Also consider the recruitment and retainment angle. Git is a widely used and very popular tool amongst developers. It’s a tool many folks want to use, and for anyone who’s learned to use Git effectively, tools like SVN can seem antiquated and kludgy. Skill acquisition is just about doing your current job better, its also about your next job and the value you can deliver in the marketplace.
Oh… getting back to GitHub specifically. I’ve worked on some teams that could not use the GitHub service. Luckily there’s https://enterprise. github ;)
I’m sure SVN is working for you. But I have every confidence that a distributed SCM would allow your teams to work even better. ;)
To get you and maybe the team accustomed to git, you can use both. Me, eg, I often use a machine-local private git repository on top of working directory of the central svn repository that stores my team’s code. In git, I can do daily commits to save larger code works incrementally that I only want to commit to the central svn repository after some time when these are tried and tested. Or I use git temporarily to stash away pending changes for a new feature when an urgent bug fix has to be done. You could even set up a small collaboration of a few team members working together on a new feature in git and only later commit this into the central svn. And when everyone’s happy with git in this way, you can switch completely … ;-)
I’m curious if you run into problems getting out of sync with the main SVN repository if you commit to it less frequently? I can see that it would be useful to be able to temporarily set aside local changes, this is interesting.
I didn’t experience sync problems to be more severe than they would have been without the git approach. It’s not that I commit less frequently into the central svn repo but that I use git as a kind of temporary vcs during the time when I cannot commit to the central svn anyway (eg, because I’m doing major refactorings that take like a week and that I want to commit into the central svn in one single step). And then, we still and always have the human sync in our team and with the product owner, so we try to organize all code changes in a way that is least likely to cause code interference and commit conflicts.
This is a very interesting post. As I commented last time, I use Subversion. For my usage-case, Git may actually be better except for one glaring difference; my boss/advisor knowns SVN and doesn’t know Git. Then, of course there is the reason a lot of people use older software; it’s what I know. I have SVN set up just so and I am pretty good at command line usage.
Also, I am grad student so I will be moving away from all this soon enough. If I were in it for the long haul, then maybe I would consider the move.
I do backup my subversion daily. It is on a central server. I run a script to first dump the repo (incrementally so I am not doing the whole thing every time), then I use rsync to pull it to my mac. Finally, it gets backed up on my mac via Backblaze and Time Machine. All in all, I have 4 to 5 copies of my repos.
I use 3 repos since they are for very different things. But this makes me wonder a few things about the BackBlaze usage.
(1): Is everything on different folders of the same repo or are they on different repos.
(2): What is your SVN backup strategy?
(3) Out of curiosity, what is your latest revision number?
I’m a developer at Backblaze and can answer a few of these:
1) Currently everything is in the same repository, I imagine this could change over time.
2) I’m not sure about this one other than knowing that the server *is* backed up.
3) Looks like 26390.
Sounds like you need to talk with Atlasssian about the benefits of GIT for remote workers…
Here's your prize — a FREE trial of Backblaze Personal Backup.
Cloud backup. Unlimited data. Automatic backup. PC or Mac. Impressionante.