É bom ter confirmações intermediárias interrompidas, desde que a confirmação final em qualquer push funcione?

Relacionado: Todo commit do git deve deixar o projeto em um estado de trabalho?

Suponha que eu faça os seguintes commit localmente:

• Modifique o esquema do banco de dados, interrompendo o aplicativo.

• Atualize o aplicativo para que seja compatível com o esquema do banco de dados novamente.

Enquanto eu pressionar os dois commits, masterpermanecerá em um estado de trabalho. No entanto, uma versão histórica está quebrada.

Estou ciente de que posso usar git rebase -ipara esmagar os commits juntos. No entanto, o commit resultante será grande e menos descritivo. Se eu precisar pesquisar no histórico de consolidação para descobrir por que mudei algo, prefiro encontrar a consolidação original mostrando o que fiz e por que.

Minhas perguntas são:

• Alguém encontrou dificuldades devido a comprometimentos históricos comprometidos no mestre?

• Em caso afirmativo, existe uma maneira simples de evitar essas dificuldades, sem descartar mensagens e alterações individuais de confirmação?

Depende em grande parte da estratégia de ramificação do seu equipamento, mas acho que ter comprometido os departamentos de desenvolvimento faz muito sentido em geral - a grande "vitória" no uso do controle de origem é poder reverter pequenas alterações e às vezes você fazendo um monte deles e você tem que quebrar ovos para fazer omeletes.

A maneira simples de manter o indivíduo confirma sem mestre poluidor é usar ramificações. Você pode colocar o material de quebra / experimental lá para ter um histórico refinado, sem poluir o histórico do ramo mestre.

Commits quebrados são algo que "simplesmente acontece", não deve significar o fim do mundo. Eu tenho uma voz irritante na parte de trás da minha cabeça que me diz que não se deve checar conscientemente o código quebrado, por uma questão de princípio e, portanto, incluindo versões históricas, no entanto, não é algo que eu iria discutir.

O muito elogiado modelo de ramificação do Git torna possível manter comprometimentos comprometidos de ramificações específicas, por exemplo, se sua equipe adota o gitflow ou uma versão simplificada do mesmo. Qualquer coisa com uma política de "mestre limpo". Nesse caso, você pode fazer o check-in da versão final de trabalho como uma consolidação de mesclagem, onde as versões históricas (quebradas) estão disponíveis no repositório, mas fora da linha principal.

Se sua equipe não adotou esse modelo de ramificação, você tem uma desculpa válida para pressionar todo o lote para dominar e acabar com ele.

Não, não está tudo bem.

Se você já fez um git bisect(e quem não ama esse recurso matador), conhece o valor de uma história em que cada commit é construído.

Se você tiver muitos commits durante um bisectque não seja construído, terá muitos git bisect skips que dificultam a localização do último bom commit.

Se você concluir uma ramificação de recurso e a mesclar no mestre, limpe a ramificação antes de mesclar para que seu histórico fique claro e em construção.

Alguém encontrou dificuldades devido a comprometimentos históricos comprometidos no mestre?

Sim. Backports, reverts e bisects são mais difíceis. O mesmo acontece com a leitura da história (veja abaixo).

Em caso afirmativo, existe uma maneira simples de evitar essas dificuldades, sem descartar mensagens e alterações individuais de confirmação?

Não que eu saiba, embora os ramos sejam uma solução decente.

No entanto, acho que descartar (ou melhor, esmagar) o indivíduo comete é a coisa certa a fazer.

Durante o desenvolvimento, especialmente ao fazer TDD, é bom se comprometer cedo e com frequência. Você quer o rastreamento completo do que está fazendo para voltar atrás ou descobrir exatamente quando as coisas começaram a dar errado (ou talvez você tenha entrado em uma refatoração maior do que pode mastigar). Comprometer-se.

No entanto, uma vez que um recurso / alteração está pronto para ser enviado, uma confirmação é uma alteração empacotada - idealmente atômica, para que possa ser [revisada, reformulada, mesclada, escolhida com cereja, revertida, visualizada em anotação] o mais independentemente de outras alterações possíveis .

Observando o histórico de um projeto, uma alteração de software deve ser avaliada por si só. Constrói? Vem com testes? Funciona? O que isso faz? Quais arquivos precisam ser alterados para oferecer esse recurso?

Ter que montar commits, enquanto possível (e auxiliado por mesclagens), torna isso mais difícil. Portanto, acho que limpar seu histórico antes de enviar é apropriado, mesmo que isso signifique perder a noção de como você chegou aonde está.

Resposta curta: Sim

Teste:

Desenvolvimento orientado a testes significa que você escreve testes que quebram (ou seja, mostram falhas).
Então você escreve o código para fazer os testes funcionarem.

Desenvolvimento:

Comprometa pequeno, comprometa-se frequentemente.
Cada confirmação é um ponto de reversão. Se você perceber que está no caminho errado, poderá reverter para um ponto anterior com relativa facilidade. Se você está comprometido, o grão é fino o suficiente, você pode reverter para o ponto correto.

Embargo:

Isso não significa

1) Você verifica o código quebrado no mestre.
2) Você precisa enviar todos os micro commits para que todos possam revisar.

Use ramos para fazer seu trabalho. Potencialmente compactar micro commits para os processos de revisão, para que eles estejam em unidades logicamente distintas com comentários apropriados. Se você estiver usando o git, não perderá o conjunto original de confirmações, basta criar um novo conjunto mais lógico de confirmações para os processos de revisão que serão mesclados no mestre.

Eu acho que, desde que os commits sejam locais e não sejam enviados a outros, não é apenas ok, é realmente uma boa maneira de trabalhar. Apenas não envie código quebrado para outras pessoas.