Todo commit do git deve deixar o projeto em um estado funcional?

Estou curioso para saber qual é a melhor prática predominante. As confirmações do git devem ser aplicadas de forma que o projeto esteja em um estado de funcionamento (é compilado corretamente, todos os testes são aprovados etc.) ou está comprometendo o código quebrado OK?

Por exemplo, se você renunciar a esse requisito, poderá ser mais flexível com confirmações (use-as como partes lógicas, mesmo que o aplicativo não esteja em um estado de funcionamento etc). No entanto, se você aplicá-lo, ganha a flexibilidade de poder escolher qualquer commit posteriormente mais tarde ...

Eu costumo seguir esta regra:

• Cada mesclagem para masterramificação deve deixar o projeto em um estado de trabalho;
• Cada mesclagem com a developramificação da linha principal deve deixar o projeto em um estado de trabalho (e deve criar pelo menos);
• O comprometimento individual de cada um tem o objetivo principal de explicar por que a mudança é feita, para que serve e quais partes do projeto foram afetadas. Todos os outros objetivos, como deixar o projeto em um estado funcional, são opcionais.

Use o seu clone local do repositório para o que for mais confortável durante o desenvolvimento.

Eu comprometo código quebrado regularmente e, quando estou pronto para disponibilizar o código para outros desenvolvedores, uso um ótimo recurso:

git rebase -i HEAD~4

Isso me permite compactar meu intermediário (neste caso, 4 deles), possivelmente quebrado, se compromete em um bom commit. Você será presenteado com um editor, permitindo que você escolha como essas confirmações são compactadas. Normalmente, marquei o primeiro commit como 'pick' e marquei os outros 'squash'.

Então, posso enviar esse commit atômico, ou, na verdade, o que faço se meu novo recurso estiver realmente pronto, é usar 'git cvsexportcommit' para colocar meu trabalho no repositório CVS existente.

Dois dos grandes benefícios do controle de versão são que ele permite que os desenvolvedores recuperem versões anteriores de seu trabalho e permite que desenvolvedores tentem mudanças diferentes e possivelmente conflitantes ao mesmo tempo. O controle de versão oferece aos desenvolvedores a liberdade de experimentar idéias que possam falhar.

Os desenvolvedores devem ser incentivados a ramificar e comprometer seu trabalho regularmente, seja ele construído ou não. Recusar-se a permitir ramificações ou confirmações quebradas é prejudicar seus desenvolvedores e fazer pouco uso de suas ferramentas.

Dito isto, é uma prática excelente exigir que os comprometimentos com certos ramos sempre sejam construídos. Muitas organizações vão além e proíbem os desenvolvedores de se comprometerem com certas ramificações. Por exemplo, talvez seja necessário que os desenvolvedores mesclem seu trabalho de volta ao ramo principal de desenvolvimento, mas apenas o desenvolvedor principal pode ter permissão para mesclar essas alterações do desenvolvimento para o ramo de produção.

Geralmente seguimos as duas abordagens. No repositório local da minha caixa, comprometo tudo o que quero. Quando é hora de passar para o repo central da minha equipe, primeiro faço uma reestruturação interativa e moldo meus commits em pacotes lógicos. Normalmente, um commit por história, com o ID da história (ou defeito) incluído no comentário (somos uma loja baseada no Kanban).

Então, em nossa reprodução central, temos Jenkins ouvindo e ela inicia a compilação e todos os testes. Se algo falhar, geralmente permitimos que as pessoas tentem consertar a compilação com outro commit. Se não estiver com boa aparência, é fácil reverter a confirmação defeituosa.

Desde a git commit afeta apenas sua própria cópia do repositório, não há necessidade de o projeto estar em um estado de trabalho após cada confirmação. Vá em frente e comprometa-se sempre que quiser salvar o trabalho que fez. Provavelmente, uma boa regra geral é que uma confirmação é apropriada quando você pode descrever as alterações feitas na mensagem de confirmação.

É git pushisso que afeta outros usuários. As políticas para o que deve ser enviado são uma questão para sua equipe de desenvolvimento decidir. Enviar código não útil para a ramificação principal é presumivelmente um não-não, mas provavelmente não há problema em enviar código não útil para uma ramificação separada (desde que ninguém mais tente fazer uma compilação a partir dessa ramificação).

Estamos usando o fluxo git no trabalho e também comprometemos código incompleto ou quebrado - pois ele só chega a ramificações locais ou remotas criadas para esse problema específico. Somente quando a tarefa é concluída, ela é mesclada na ramificação de desenvolvimento (que representa a cópia de trabalho atual no modelo de fluxo). Dessa forma, também podemos colaborar no código (alguns colegas de trabalho estão em outra cidade, incluindo o líder do projeto) e ajudar um ao outro.

No entanto, isso depende de como você e seus colegas de trabalho estão pensando. Pessoalmente, acho que os commits de ramificação são bons, pois você pode precisar de um histórico de alterações com um refator maior ou similar.

Em última análise, cabe a você e às pessoas com quem trabalha ou para, já que o git não impõe nenhuma regra.

Minha prática é evitar qualquer confirmação que intencionalmente torne o sistema significativamente pior. Cada confirmação deve ser refatorada ou implementar algum requisito. Se eu fizer um commit ruim e o descobrir antes de enviá-lo, alterarei ou refizerei para removê-lo do histórico.

Eu acho que isso facilita a leitura do log do git em uma solicitação pull, já que cada commit deve permanecer por si só como refatoração ou implementação de algum requisito. Adicionar código morto que será trazido à vida em um futuro próximo conta como uma refatoração. Estes são os meus 'pedaços lógicos'.

Você ainda pode ser flexível com a estrutura de seus commits. Por exemplo, você pode escrever testes com antecedência, mas marcá-los como ignorados no primeiro commit, para que seu conjunto de testes não relate uma falha e, em seguida, desmarque-os quando a implementação estiver concluída.

Supondo que você esteja usando ramificações e boas mensagens de confirmação, confirme o código "quebrado" em uma ramificação com uma mensagem de confirmação que deixe isso bem, desde que sua equipe concorde que é uma boa prática de trabalho.

Você também clona o repositório git localmente, portanto pode ter apenas uma ramificação local com confirmações locais não enviadas para a origem, onde está cometendo código "quebrado" à medida que avança; então, quando tudo estiver funcionando, você poderá mesclá-lo no master ou em alguma outra ramificação e excluir sua ramificação de trabalho com os vários commits "quebrados".

Para mim, é tudo uma questão de concordar com sua equipe o que é aceitável; algumas equipes não aceitam código quebrado mesmo em uma filial, outras aceitam.