Confirmar / verificar código todos os dias é uma boa prática?

63

Eu tenho lido a nota de Martin Fowler sobre Integração Contínua e ele lista como obrigatório "Todo mundo se compromete com a linha principal todos os dias".

Não gosto de confirmar código, a menos que a seção em que estou trabalhando esteja completa e que, na prática, confirmo meu código a cada três dias: um dia para investigar / reproduzir a tarefa e fazer algumas alterações preliminares, um segundo dia para concluir as alterações. e um terceiro dia para escrever os testes e limpá-los ^ para envio. Eu não me sentiria confortável enviando o código mais cedo.

Agora, retiro as alterações do repositório e as integro localmente geralmente duas vezes por dia, mas não as submeto com frequência, a menos que consiga realizar um trabalho menor.

Pergunta: está cometendo todos os dias uma prática tão boa que devo alterar meu fluxo de trabalho para acomodá-lo ou isso não é aconselhável?

Edit: Eu acho que deveria ter esclarecido que eu quis dizer "commit" no significado do CVS (também conhecido como "push"), já que é provavelmente o que Fowler teria significado em 2006 quando ele escreveu isso.

A ordem é mais arbitrária e depende da tarefa. Meu objetivo era ilustrar o período e as atividades, e não a seqüência exata.

version-control Trenó
fonte
20
Você pode confirmar seu código se ele compilar e executar alguma lógica útil. É melhor confirmar o código em ciclos curtos se você estiver trabalhando em um ambiente de equipe.
EL Yusubov 05/07/2012
4
Martin Fowler está assumindo um VCS que não é distribuído?
user16764
4
Observe a data desse artigo: 1º de maio de 2006. Git e Mercurial nem começaram em abril de 2005, e minha impressão é que eles realmente começaram a ganhar força por volta de 2008. Não consigo encontrar nenhum artigo no site de Fowler que se refira para qualquer um deles antes de 2009. Portanto, este artigo de 2006 assume claramente um sistema de controle de fonte centralizado como o SVN. O conselho não é aplicável a equipes que usam um DVCS.
Kyralessa 6/07/12
2
@ Kyralessa: O artigo ainda afirma que "o Subversion é o moderno [sistema de controle de versão]".
che
4
Primeiro o código e depois os testes?

Respostas:

43

Não concordo com essa regra e concordo com o que Mason Wheeler disse. Eu gostaria de adicionar algumas idéias.

Eu tento confirmar cada vez que tenho uma alteração significativa a ser confirmada: isso pode ser várias vezes ao dia se eu corrigir vários bugs pequenos ou uma vez por semana se estiver trabalhando em um software maior que não pode ser usado pelo restante da atualização. o código de qualquer maneira significativa até atingir um estado consistente.

Além disso, interpreto o comprometimento como publicação de uma revisão significativa que contribui com novas funcionalidades para a base de código. Acho que se deve tentar limpar o código antes de se comprometer, para que outros desenvolvedores possam entender o significado e o objetivo da mudança quando analisarem o histórico de revisões. Quanto menos alterações os outros desenvolvedores veem na história, melhor: quando eu olhar para o histórico de revisões, quero ver incrementos que adicionam alguma funcionalidade significativa; Não estou interessado em todas as pequenas ideias que cada desenvolvedor teve e queria experimentar antes de chegar à solução.

Além disso, não acho que seja uma boa ideia usar o servidor SVN (ou qualquer outro sistema de controle de versão) como um recurso de backup no qual o instantâneo atual do código está comprometido (desde que seja compilado): você pode usar um pendrive ou uma unidade USB externa ou um disco de rede para espelhar seu código atual, para que não se perca se o computador quebrar. Controle de revisão e backup de dados são duas coisas diferentes. Publicar uma revisão não é o mesmo que salvar um instantâneo do seu código.

Finalmente, acho que não deve ser um problema comprometer-se de vez em quando (ou seja, apenas quando alguém estiver realmente satisfeito com o estado atual do código) e evitar conflitos de mesclagem não é uma boa justificativa para cometer (com muita freqüência). Muitos conflitos de mesclagem acontecem quando pessoas diferentes trabalham nos mesmos arquivos ao mesmo tempo, o que é uma má prática (veja, por exemplo, este artigo , ponto 7). Os conflitos de mesclagem devem ser reduzidos dividindo um projeto em módulos com interfaces claras e o menor número possível de dependências, e coordenando o trabalho dos desenvolvedores para que o código no qual eles trabalham se sobreponha o mínimo possível.

Apenas meus 2 centavos.

EDITAR

Outro motivo contra comprometimentos prematuros que me veio à cabeça é que uma versão (muito) de buggy não pode ser testada. Se você está comprometendo o tronco e sua equipe de teste está testando todos os dias, eles podem não ter uma versão testável por algumas horas (ou por um dia). Mesmo se você não tentar corrigir o bug e apenas reverter suas alterações, uma reconstrução poderá demorar algumas horas. Com, digamos, cinco testadores trabalhando em sua equipe, você perdeu 5 x 2 = 10 horas do tempo da equipe devido à inatividade. Isso aconteceu comigo uma vez, então eu realmente tento evitar confirmações prematuras em nome da confirmação o mais rápido possível .

Giorgio
fonte
23
Um 'commit' não é um 'publish'. 'Confirmar' significa 'instantâneo'; 'publish' é chamado de 'push' no scm-lingo. Obviamente, o SVN apenas mescla os dois conceitos em um, impossibilitando muitos fluxos de trabalho sensíveis, mas isso é uma limitação da ferramenta, não dos fluxos de trabalho de controle de origem em geral.
tdammers
3
Revision control and data backup are two different thingsSim, definitivamente me sinto assim.
Sled
11
@ Tdammers: eu quis dizer publicar de uma maneira informal: Enquanto o código estiver no meu computador, serão minhas alterações privadas no código comum. Assim que eu o comprometo, ele é publicado, conhecido pelo restante da equipe e parte da história oficial do projeto.
Giorgio
11
Nesse caso, 'confirmar' é provavelmente a palavra errada. Muitos SCMs permitem confirmações locais, e compartilhar seu código com o restante da equipe é uma ação separada, geralmente chamada de 'push'. Novamente, o SVN agrupa os dois conceitos, mas isso é uma limitação da ferramenta e, se ela atrapalhar o seu fluxo de trabalho, considere mudar para um SCM diferente.
tdammers
@ tdammers: Ter uma distinção clara entre o commit e a publicação local seria um passo à frente. No SVN, posso usar um ramo separado para isso. Mas, novamente, eu me pergunto por que eu gostaria de acompanhar uma revisão que não faz muito sentido para mim? Não estou convencido de que quero uma nova revisão (mesmo uma particular) apenas porque são 5 horas e estou voltando para casa. Prefiro ter um backup.
Giorgio
107

Eu comprometo o código várias vezes ao dia . Sempre que chego a um ponto em que o código está completo o suficiente para compilar e não quebra outras coisas, ele entra.

Você deve analisar seu trabalho para poder fazer o check-in com segurança algumas vezes ao dia.

As razões para isso são duas:

  1. Qualquer trabalho que não esteja registrado pode ser perdido - seu computador pode ter uma falha catastrófica. Nesse caso, quanto mais você espera, mais trabalho perde.
  2. Quanto mais você trabalha sem fazer check-in, mais código os outros precisarão integrar quando você finalmente decidir que é necessário. Isso apresenta mais chances de conflitos e problemas de mesclagem.
Oded
fonte
2
Se você tiver um problema sério com conflitos e problemas de mesclagem, isso significa que seu gerente de projeto não está fazendo o trabalho dele. Múltiplos casos envolvendo funcionalidade semelhante devem ir para o mesmo desenvolvedor, precisamente para que você não tenha dois ou mais codificadores impedindo o trabalho um do outro.
Mason Wheeler
14
@MasonWheeler - Após três dias de trabalho que não foi confirmado, há uma chance muito boa de que alguém tenha tocado no código que outros possuem ao mesmo tempo. Se você tem vários programadores fazendo isso, o melhor gerente de projetos não pode evitar a ocorrência de conflitos.
Oded
3
@Oded: Talvez. Suponho que minha resposta seja colorida pela minha experiência em uma base de código grande o suficiente para que nossos desenvolvedores (cerca de uma dúzia de codificadores da equipe) tendam a ter responsabilidades não sobrepostas. Não tenho certeza de quão diferente seria em projetos menores.
Mason Wheeler
3
@ArtB - E se houver alguém como você que só faça check-in a cada 3 dias? Ou uma vez por semana? Você está confiando em outras pessoas fazendo a coisa certa.
Oded
3
Quando li a pergunta, minha resposta foi "é como perguntar se é uma boa idéia tomar banho toda semana"?
Andrew Grimm
39

Aderir de maneira servil a qualquer metodologia ou prática sem entender as razões por trás disso nunca é uma boa idéia. É daí que vem a programação do culto à carga.

Portanto, "eu deveria me comprometer todos os dias porque Martin Fowler disse isso" é simplesmente estúpido. E às vezes também é impraticável. Se você estiver trabalhando em um novo recurso complicado, poderá não chegar a um ponto em que valha a pena conferir até que você já trabalhe nele por alguns dias.

Isso não significa que você deve garantir que tudo esteja perfeito antes de fazer o check-in. Essa é uma boa maneira de perder o trabalho se algo der errado. A coisa correta a fazer é desenvolver e usar o bom senso sobre o assunto. As regras práticas podem apenas ajudá-lo muito.

Mason Wheeler
fonte
11
Então, se é uma integração / desenvolvimento de recursos complexos, ainda é uma grande perda não comprometê-los, talvez não no tronco, mas pelo menos em um ramo para esse recurso, é para isso que servem os ramos!
Vincent B.
2
O que você quer dizer com 'vale a pena conferir'? Se ele não quebra o código de mais ninguém, por que você não o registrou?
Kirk Broadhurst
2
"O que você quer dizer com 'vale a pena conferir'? Se não quebra o código de mais ninguém, por que você não o verifica?": Porque eu não quero manter cópias antigas do código apenas porque elas existiam ponto no tempo. Também quero manter uma cópia antiga do código, se ele contiver algumas informações úteis que eu possa querer recuperar no futuro. Caso contrário, estou apenas produzindo ruído inútil no histórico de revisões.
Giorgio
3
+1. Certa vez, trabalhei em uma equipe na qual tínhamos que verificar o código nos vcs todos os dias, mesmo que o código fosse um pico ou uma investigação inútil. Ele se mostrou ineficiente e inútil, principalmente porque exigia manutenção periódica para limpar os vcs. Isso ocorreu devido à combinação de paranóia, com o risco de perder um pouco de tempo para refazer algo, e porque o gerente tinha lido um livro que você deveria comprometer todos os dias. Um exemplo extremo, talvez, mas a sério, se você não tem o juízo de saber se "vale a pena" checar algo, provavelmente não é adequado para o trabalho.
31712 S.Robins
14

Oded deu duas razões importantes para confirmar o código com a maior frequência possível. Vou adicionar mais alguns:

  1. Enquanto trabalhava em seu trecho de código, outros podem precisar de algumas funções nesse código. Eles não devem esperar 6 dias para obtê-lo. Nesse caso, meus colegas geralmente criam um protótipo no meu pedaço de código, o comprometem, eu adiciono o corpo e o comprometo novamente. E isso geralmente é feito em algumas horas.

  2. O código 'comum' é para que todos vejam todas as alterações o mais rápido possível. Se o trecho de código no qual você está trabalhando é totalmente separado do trabalho de outras pessoas e você não espera que eles esperem, é recomendável criar um ramo para você trabalhar e, se tudo der certo, mescle-o para a linha principal.

superM
fonte
11
Por que esta resposta com (IMO) é a única resposta correta e precisa (ponto 2) tão baixa classificação ?! Claro que esse é o objetivo de um galho! @Mason Wheeler: Então você gosta de codificar vários dias em uma matéria-prima sem cometer uma única vez? Então, por que usar um sistema de controle de versão ?!
22468 Vincent B.
2
Essa é a resposta correta. Se sua tarefa tiver muitos dias de trabalho antes de ser utilizável, ramifique. Caso contrário, você confirma sempre que funciona para garantir que os membros da equipe tenham a versão mais recente, eles podem testar se funciona e identificam os recursos adicionados / ausentes o mais rápido possível.
22412 Kirk Broadhurst
"Então você gosta de codificar vários dias em uma matéria-prima sem confirmar uma única vez? Então, por que usar um sistema de controle de versão?!": Porque, eventualmente, você deseja confirmar uma revisão, mesmo que não seja obrigado a confirmar cegamente todos os dias. Em vez disso, cabe a você decidir se comete várias vezes ao dia ou se trabalha três dias seguidos sem se comprometer. Realmente não vejo sentido em comprometer algum recurso inacabado que ninguém pode usar: basta fazer um backup, no dia seguinte você pode concluir e confirmar.
Giorgio
8

Acredito firmemente em cometer todas as mudanças lógicas que valem a pena ser mantidas. Confirme com frequência e, se não vale a pena manter o código, volte ao estado limpo. Quanto mais você esperar para enviar / publicar seu código de volta, mais difícil será implementar e mais problemas você terá. Você também receberá comentários sobre suas contribuições muito mais rapidamente:

  • eles quebram a construção?
  • você está duplicando os esforços de outro membro da equipe?
  • você está fazendo algo incorreto?
  • ou as pessoas estão esperando por você?

Pequenas mudanças são muito mais fáceis de gerenciar.

Além disso, vale a pena notar a diferença entre diferentes sistemas de controle de versão. Alguns, como o Git (distribuído), permitem confirmar e controlar todo o seu histórico localmente, pressionando apenas quando você estiver pronto para publicar. Outros, como o SVN (centralizado), combinam as duas etapas, tornando os pequenos commits muito ineficientes.

Não esqueça que seus commits são essencialmente documentação de alterações. Quando as coisas dão errado, você ficará feliz em ter mais história do que não o suficiente. Um único commit por um período de semanas parece inútil para mim. Acabaria lendo cada linha de código alterada, em vez do resumo de cada parte lógica.

Adrian Schneider
fonte
5

Acho que a maioria das respostas aqui perde um dos principais pontos da declaração de Martin Fowlers. Isso está relacionado à integração contínua . O código que não está registrado (enviado / publicado / mesclado) na linha principal não é testado.

Isso não deve ser lido como um incentivo para confirmar qualquer código que você tenha em sua máquina local sempre que for hora de sair do escritório. Como apontado por vários outros aqui, isso seria ruim, quebraria a compilação e causaria uma linha principal instável.

No entanto, é recomendável encorajar as alterações em pequenas etapas que podem ser registradas na linha principal sem causar problemas. Isso incentiva a evolução do código em vez de rasgar tudo e reescrever.

Agora, o que há de bom nessa maneira de trabalhar?

  1. Não cometer grandes pedaços de código ou mudanças revolucionárias reduz a chance de quebrar a compilação.
  2. Se o seu commit interrompe a compilação, é bastante trivial identificar quais são os problemas, revertê-lo e confirmar uma versão fixa rapidamente.
  3. Ao garantir que todos os testes sejam executados em todas as pequenas alterações no código, você garante que não introduza bugs ou regressões sutis que podem resultar do crescimento do código fora do esquema de integração contínua.

É claro que nem todas as mudanças se prestam a essa abordagem. Como outros apontaram, nenhuma regra é absoluta. No entanto, para alterações que devem permanecer fora da linha principal por um longo tempo, configure uma linha principal alternativa com seu próprio esquema de integração contínua e siga a mesma abordagem. Com os VCS distribuídos de hoje, isso é algo bastante fácil de fazer.

harald
fonte
+1: "É claro que nem todas as mudanças se prestam a essa abordagem." Eu acho que esse é o ponto. Acho que o conselho de Fowler está bem, mas deve-se julgar caso a caso. Em vez disso, esse conselho geralmente é generalizado para uma regra absoluta e seguido sem nenhuma consideração adicional.
Giorgio
@Giorgio, concordo plenamente com você. Nenhum conselho deve ser tomado como regra absoluta, independentemente de quem está por trás dele.
Harald
Mais algumas idéias sobre isso. "O código que não foi registrado (enviado / publicado / mesclado) na linha principal não é testado.": Concordo que esse é um bom princípio e não se deve esperar semanas antes de fazer o check-in e fazer o teste do código. No entanto, a aplicação cega desse princípio pode levar a uma aplicação quebrada que nem pode ser testada (eu já vi isso ao vivo: toda a equipe de teste fica ociosa por dias e não pode testar nada até que o código volte ao estado utilizável). Talvez o que outros usuários tenham escrito seja aplicável a algumas situações, mas não seja em geral.
Giorgio
11
Verificar código instável nunca é bom. Uma confirmação que quebra o IC deve ser revertida. Se você cometer pequenas alterações incrementais com frequência, há menos chances de introduzir essa quebra do que se você tiver uma grande alteração que não foi testada por um longo tempo. Também pode ser mais fácil reverter se interromper a compilação. Mas, como você diz, às vezes não há como sair de uma mudança perturbadora. Então, por todos os meios, faça o melhor que puder e teste minuciosamente antes de cometer. O ponto não é seguir regras, mas entender de onde vem o conselho.
Harald
3

Argumentos para o check-in todos os dias:

  • O código é armazenado e protegido contra falha no disco rígido
  • A atividade pode ser registrada nas notas de confirmação ( o que eu fiz na quinta-feira ...? )
  • A integração com a base de código existente acontece mais cedo e em partes menores, provavelmente identificando conflitos ou mesclando problemas mais cedo
  • Sua equipe tem visibilidade do que você está trabalhando
  • Seus colegas podem trabalhar com suas interfaces mais cedo, dando-lhes mais tempo para se integrarem ao seu 'grande e complexo código'
  • Seu código será testado no mundo real mais cedo, ou pelo menos exposto a mais uso do que o permitido, levando à identificação anterior de bugs ou omissões.

Argumentos contra o check-in todos os dias:

  • Não precisa ou não quer
  • Ainda não 'limpei' meu código, está uma bagunça
  • Não tem tempo

Não acredito que exista uma boa razão para fazer check-in menos que diariamente, além de preguiça ou desorganização. Nada pior do que ver o código em execução no ambiente de desenvolvimento não corresponde ao código na ramificação de desenvolvimento porque alguém 'ainda não terminou' e, portanto, não fez check-in.

Eu adoraria estar errado nisso, por favor, deixe-me saber qualquer argumento legítimo contra o check-in diário.

Kirk Broadhurst
fonte
"Não acredito que exista uma boa razão para fazer check-in menos que diariamente, além de preguiça ou desorganização.": Acredito o contrário exatamente pela mesma razão. Posso reservar um tempo para analisar o estado atual do código e decidir se ele contém algumas informações relevantes que valem a pena lembrar, ou, se eu sou preguiçoso e desorganizado, posso simplesmente fazer check-in (e fazer revisões extras com poucas informações) conteúdo), desde que seja compilado.
Giorgio
11
Entendo que você não deve ser preguiçoso e limpar seu código todos os dias para que possa fazer check-in. Por outro lado, ao trabalhar em algum código complexo, isso é difícil de conseguir, porque a limpeza pode levar várias horas , e você não pode passar várias horas todos os dias apenas para limpar seu código.
Giorgio
@Giorgio Então você passa vários dias limpando seu código? Forneci algumas boas razões para fazer check-in diariamente - seu motivo é que você precisará limpar seu código? Basta escrever um código mais limpo.
22412 Kirk Broadhurst
Isso nem sempre é possível, por exemplo, se estou desenvolvendo do zero algum código complexo (> 4000 LOC) que precisa de muita experimentação para acertar. É bem possível que no final do dia o código esteja um pouco confuso e não quero corrigi-lo até que eu chegue a um estado consistente, que é alguns dias depois. Infelizmente, não sou tão esperto que tenha terminado, formulários de código perfeitos em minha mente e sempre posso escrever tudo em poucas horas (ou seja, no final de um dia). Ultimamente, tive uma experiência dessas e o ciclo de desenvolvimento típico (de um estado consistente para o seguinte) foi de 2, 3 dias.
Giorgio
@Giorgio, você não tem um ramo de desenvolvimento no qual está verificando? O código deve ser verificado para que outras pessoas possam revisá-lo e testá-lo também.
precisa
2

Se você quer dizer "confirmar" como "mesclar na linha principal", definitivamente não deve fazer isso todos os dias em um projeto de software que está sendo lançado para os clientes. Você deve mesclar as alterações feitas e testadas, para que a linha principal esteja sempre funcionando e liberável, e não em um estado interrompido, com recursos pela metade.

No entanto, o luxo de trabalhar com o controle de versão distribuído de hoje é que você pode manter a linha principal estável e, ao mesmo tempo, git/hg/whatever commitsempre que sentir que deseja preservar o estado das coisas. Faço isso uma vez a cada poucas horas e definitivamente no final de cada dia.

Com o DVCS, você pode publicar seu trabalho, colaborar com outras pessoas da sua equipe e mantê-lo atualizado com as alterações na ramificação da linha principal. Você pode fazer tudo isso sem poluir a estabilidade do código de que seus clientes e / ou outras equipes dependem.

Nos tempos em que o Subversion era a tecnologia mais recente e não havia como forçar e mesclar ramificações de recursos sem muita dor, ter uma linha principal onde vários recursos diferentes estavam em construção simultânea poderia ter sido a melhor abordagem. Mas essa superioridade não escala além de 2010.

che
fonte
2

No Team Foundation Server, você pode 'Arquivar', que não é o mesmo que um check-in, mas apenas faz um backup do seu código para que, se sua máquina morrer, você não perca as alterações.

Eu também vi casas de software que têm uma 'linha de desenvolvedor' e uma 'linha principal'. Os desenvolvedores podem fazer o check-in na linha do desenvolvedor sempre que acharem adequado e apenas o líder da equipe tem acesso à linha principal, de modo que eles são responsáveis ​​por copiar o código do dev para o main quando a produção estiver pronta.

Matt Wilko
fonte