Quantas vezes confirmar alterações no controle de origem? [fechadas]

Com que frequência devo confirmar alterações no controle de origem? Depois de cada recurso pequeno ou apenas de recursos grandes?

Estou trabalhando em um projeto e tenho um recurso de longo prazo para implementar. Atualmente, eu estou comprometendo após cada parte do trabalho, ou seja, cada sub-recurso implementado e corrigido o erro. Eu até cometi depois de adicionar um novo bloco de testes para algum recurso depois de descobrir um bug.

No entanto, estou preocupado com esse padrão. Em um dia produtivo de trabalho, posso fazer 10 confirmações. Dado que estou usando o Subversion, esses commits afetam todo o repositório, então eu me pergunto se é realmente uma boa prática fazer tantos?

Sempre que eu concluo um "pensamento completo" do código que compila e executa o check-in. Isso geralmente acaba entre 15 e 60 minutos. Às vezes, pode demorar mais, mas sempre tento verificar se há muitas alterações de código que não gostaria de reescrever em caso de falha. Também costumo garantir que meu código seja compilado e faça o check-in no final do dia de trabalho antes de voltar para casa.

Eu não me preocuparia em fazer "muitos" confirmações / check-ins. É realmente péssimo quando você tem que reescrever algo, e é bom poder reverter em pequenos incrementos, por precaução.

Quando você diz que está preocupado com o fato de seus "commits afetarem todo o repositório" - você está se referindo ao fato de que o número de revisão do repositório inteiro aumenta? Não sei quantos bits o Subversion usa para armazená-lo, mas tenho certeza de que você não ficará com os números das revisões! Muitos commits não são um problema. Você pode cometer dez vezes mais que o vizinho e não aumentará sua pegada de carbono.

Uma única função ou método deve ser nomeado para o que faz e, se o nome for muito longo, estará fazendo muito. Tento aplicar a mesma regra aos check-ins: o comentário do check-in deve descrever exatamente o que a alteração realiza e, se o comentário for muito longo, provavelmente estou mudando muito de uma só vez.

Gosto deste pequeno artigo de Jeff Atwood: faça o check-in mais cedo, faça o check-in frequentemente

Pessoalmente, comprometo todos os grupos lógicos de código concluídos / estáveis ​​/ compilados e tento não sair do dia sem confirmar o que fiz naquele dia.

Se você estiver fazendo grandes alterações e estiver preocupado em afetar outras pessoas que trabalham no código, poderá criar uma nova ramificação e voltar a entrar no tronco após a conclusão das alterações.

Comprometo sempre que termino uma tarefa. Isso geralmente leva de 30 minutos a 1 hora.

Se o seu comentário de controle de versão tiver mais de uma ou duas frases, você provavelmente não estará comprometendo com frequência suficiente.

Eu sigo o mantra de código aberto (parafraseado) - comprometa-me cedo, comprometa-me frequentemente.

Basicamente, sempre que penso que adicionei funcionalidade útil (por menor que seja) sem apresentar problemas para outros membros da equipe.

Essa estratégia de confirmação frequente é particularmente útil em ambientes de integração contínua, pois permite testes de integração com outros esforços de desenvolvimento, permitindo a detecção precoce de problemas.

Não confirme código que realmente não funcione. Não use seu repositório como uma solução de backup.

Em vez disso, faça backup do seu código incompleto localmente de forma automatizada. O Time Machine cuida de mim e há muitos programas gratuitos para outras plataformas.

A regra geral, que eu uso, é o check-in quando o grupo de arquivos que está sendo verificado pode ser coberto por um único comentário de check-in.

Isso geralmente garante que os check-ins sejam atômicos e que os comentários possam ser facilmente digeridos por outros desenvolvedores.

É especialmente verdade quando suas alterações afetam um arquivo de configuração (como um arquivo de contexto spring ou um arquivo de configuração do struts) que possui um amplo escopo de aplicativo. Se você fizer vários 'grupos' de alterações antes do check-in, seu impacto será sobreposto no arquivo de configuração, fazendo com que os dois grupos sejam mesclados.

Eu não acho que você deva se preocupar tanto com a frequência. O importante aqui é o que, quando e por quê. Dizer que você precisa se comprometer a cada 3 horas ou a cada 24 horas realmente não faz sentido. Confirme quando tiver algo a confirmar, não se não tiver.

Aqui está um extrato das minhas práticas recomendadas para controle de versão :

[...] Se você estiver fazendo muitas alterações em um projeto ao mesmo tempo, divida-as em partes lógicas e confirme-as em várias sessões. Isso facilita muito o rastreamento do histórico de alterações individuais, o que poupa muito tempo ao tentar encontrar e corrigir erros posteriormente. Por exemplo, se você estiver implementando os recursos A, B e C e corrigindo os erros 1, 2 e 3, isso resultará em um total de pelo menos seis confirmações, uma para cada recurso e uma para cada bug. Se você estiver trabalhando em um grande recurso ou realizando uma refatoração extensa, considere dividir seu trabalho em partes ainda menores e faça uma confirmação após a conclusão de cada parte. Além disso, ao implementar alterações independentes em vários módulos lógicos, confirme as alterações em cada módulo separadamente, mesmo que façam parte de uma alteração maior.

Idealmente, você nunca deve sair do escritório com alterações não confirmadas no disco rígido. Se você estiver trabalhando em projetos nos quais as mudanças afetarão outras pessoas, considere usar uma ramificação para implementar suas alterações e mesclá-las novamente ao tronco quando terminar. Ao confirmar alterações em bibliotecas ou projetos dos quais outros projetos - e, portanto, outras pessoas - dependem, certifique-se de não quebrar suas construções, comprometendo o código que não será compilado. No entanto, ter um código que não é compilado não é uma desculpa para evitar a confirmação. Use ramos em vez disso. [...]

Seu padrão atual faz sentido. Lembre-se de como você usa esse controle de origem: e se você precisar reverter ou se quiser fazer uma diferença? Os pedaços que você descreve parecem exatamente o diferencial certo nesses casos: o diff mostrará exatamente o que mudou na implementação do bug # (especificado no log de check-in) ou exatamente o que o novo código era para implementar um recurso. A reversão, da mesma forma, tocará apenas uma coisa de cada vez.

Também gosto de me comprometer depois de terminar um pedaço de trabalho, o que geralmente ocorre várias vezes ao dia. Eu acho que é mais fácil ver o que está acontecendo nos commits pequenos do que nos grandes. Se você estiver preocupado com muitas confirmações, considere criar uma ramificação e mesclá-la de volta ao tronco quando todo o recurso for concluído.

Aqui está um post de blog relacionado: Coding Horror: Check In Early, Check In Freqüentemente

Como outros já declararam, tente confirmar um pedaço lógico que é "completo" o suficiente para não atrapalhar os outros desenvolvedores (por exemplo, cria e passa nos testes automatizados).

Cada equipe / empresa de desenvolvimento deve definir o que é "suficientemente completo" para cada filial. Por exemplo, você pode ter ramos de recursos que requerem apenas o código para construir, um tronco que também exige que o código seja aprovado em testes automatizados e rótulos indicando que algo passou no teste de controle de qualidade ... ou algo assim.

Não estou dizendo que esse é um bom padrão a seguir; Estou apenas salientando que o modo como o trabalho é realizado depende das políticas da sua equipe / empresa.

No momento em que você pensa sobre isso.

(desde que o check-in seja seguro)

Depende do seu sistema de código-fonte e do que mais você possui. Se você estiver usando o Git, faça o commit sempre que terminar uma etapa. Eu uso o SVN e gosto de confirmar quando finalizo um recurso inteiro, portanto, a cada uma a cinco horas. Se eu estivesse usando o CVS, faria o mesmo.

Eu concordo com várias das respostas: não faça check-in de código que não será compilado; use uma ramificação ou repositório pessoal se sua preocupação é ter um "backup" do código ou de suas alterações; faça check-in quando as unidades lógicas estiverem concluídas.

Outra coisa que eu acrescentaria é que, dependendo do seu ambiente, a taxa de check-in pode variar com o tempo. Por exemplo, no início de um projeto, o check-in após a conclusão de cada parte funcional de um componente faz sentido tanto para a segurança quanto para o histórico de revisões (estou pensando nos casos em que os bits anteriores são refatorados à medida que os posteriores estão sendo desenvolvidos). Posteriormente, no projeto, por outro lado, funcionalidades completamente completas se tornam mais importantes, especialmente durante o desenvolvimento / teste de integração. Uma meia integração ou meia correção não ajuda ninguém.

Quanto ao check-in após cada correção de bug: a menos que a correção seja trivial, absolutamente! Nada é mais doloroso do que descobrir que um check-in continha três correções e uma delas precisava ser revertida. Na maioria das vezes, parece que nessa situação o desenvolvedor corrigiu três bugs em uma área e desenrolou qual mudança foi para qual correção de bugs é um pesadelo.

Também gosto de fazer check-in regularmente. Toda vez que dou um passo em direção ao meu objetivo.

Isso geralmente ocorre a cada duas horas .

Minha dificuldade é encontrar alguém disposto e capaz de executar tantas revisões de código .

Nossa política da empresa é que precisamos fazer uma revisão de código antes que possamos fazer o check-in, o que faz sentido, mas nem sempre há alguém no departamento que tem tempo para executar imediatamente uma revisão de código. Soluções possíveis:

1. Mais trabalho por check-in; menos entradas == menos avaliações.
2. Altere a política de check-in da empresa. Se acabei de refatorar e os testes de unidade ficam verdes, talvez eu possa relaxar a regra?
3. Arquive a alteração até que alguém possa executar a revisão e continuar trabalhando. Isso pode ser problemático se o revisor não gostar do seu código e precisar reprojetar. Fazer malabarismos com diferentes estágios de uma tarefa ao "arquivar" as mudanças pode ficar confuso.

Eu gosto de confirmar alterações a cada 30-60 minutos, desde que seja compilado corretamente e não haja regressões nos testes de unidade.

Bem, você pode ter seu próprio ramo com o qual pode se comprometer quantas vezes quiser e, quando terminar seu recurso, poderá mesclá-lo ao tronco principal.

Na frequência do Commits, penso assim: quanta dor seria para mim se meu disco rígido travasse e eu não tivesse cometido algo - o quantum desse algo para mim é de cerca de 2 horas de trabalho.

Obviamente, nunca cometo algo que não compila.

Pelo menos uma vez ao dia.

Não tenho um limite de tempo específico por confirmação, tendo a confirmação assim que o teste é aprovado e estou feliz com o código. Eu não confirmaria código que não seja compilado ou esteja em um estado que não me sentiria bem em reverter para o caso de falha

Você precisa equilibrar o compromisso entre segurança e capacidade de recuperação, por um lado, e a facilidade de gerenciamento de mudanças para todo o projeto, por outro.

O melhor esquema que usei teve duas respostas para essa pergunta.

Usamos dois repositórios completamente separados: um era o repositório amplo do projeto e o outro era o nosso próprio repositório pessoal (estávamos usando rcs na época).

Nós checávamos nosso repositório pessoal com muita frequência, praticamente toda vez que você salvava seus arquivos abertos. Como tal, o repositório pessoal era basicamente um buffer grande e longo de desfazer.

Depois que tínhamos um pedaço de código que seria compilado, testado ok e aceito como pronto para uso geral, ele foi verificado no repositório do projeto.

Infelizmente, este sistema contou com o uso de diferentes tecnologias VCS para ser viável. Não encontrei nenhum método satisfatório para obter os mesmos resultados ao usar dois VCS do mesmo tipo (por exemplo, dois repositórios do subversion)

No entanto, tive resultados aceitáveis ​​criando ramificações de desenvolvimento "pessoais" em um repositório do subversion - verificando regularmente a ramificação e depois mesclando-a no tronco após a conclusão.

Se você estiver trabalhando em uma ramificação que não será liberada, uma confirmação será sempre segura.

No entanto, se você o compartilhar com outros desenvolvedores, a confirmação de código não útil provavelmente será um pouco chata (principalmente se estiver em um local importante). Normalmente, eu apenas confirmo o código que está efetivamente "funcionando" - não que ele tenha sido totalmente testado, mas verifiquei que ele realmente compila e não falha imediatamente.

Se você estiver usando um rastreador de erros integrado, pode ser útil realizar confirmações separadas se você tiver corrigido dois bugs, para que o log de confirmação possa ir contra os erros corretos. Mas, novamente, às vezes uma alteração de código corrige dois bugs, então você só precisa escolher qual deles deve ser combatido (a menos que seu sistema permita que uma confirmação seja associada a vários bugs)

Ainda acredito na frase 'comprometer-se frequentemente, comprometer-se cedo'. Eu prefiro VCS descentralizados como Mercurial e não há problema em cometer várias coisas e empurrá-lo para cima mais tarde.

Esta é realmente uma pergunta comum, mas a verdadeira questão é: você pode confirmar código inacabado?

Sempre que você terminar algum código que funcione e não estrague mais ninguém, se ele o receber em uma atualização.

E por favor, certifique-se de comentar corretamente.