Diviser les progrès de codage en validations significatives sans trop de frais généraux

Lorsque je travaille sur un correctif ou une fonctionnalité, je tombe parfois sur d'autres petits problèmes qui peuvent être améliorés à la volée en quelques secondes. Lorsque je les fais immédiatement, puis que je valide la fonctionnalité / correction terminée, la validation inclut plus d'une chose. Par exemple "add feature X and code clean up"ou "fix bug X and improved logging". Il serait préférable de diviser cela en deux commits. Dans le cas où les deux changements se sont produits dans le même fichier, je ne peux pas simplement ajouter un fichier, valider, ajouter l'autre puis recommencer. Je vois donc les trois options suivantes:

1. Oubliez délibérément les choses non liées tout en travaillant sur quelque chose.

2. Copiez le fichier avec deux modifications, annulez-le, incluez une modification, validez, incluez l'autre modification, validez à nouveau.

3. Ne modifiez pas les petites choses sans rapport, mais ajoutez-les à une liste de tâches et faites-les plus tard.

Je n'aime pas vraiment les trois options, pour les raisons suivantes:

1. La qualité du code peut souffrir si l'on ne résout pas les petits problèmes. Et je me sens mal si je manque consciemment une chance d'améliorer quelque chose sans trop d'effort.

2. Cela augmente le travail manuel et est sujet aux erreurs.

3. C'est bien pour les tâches pas si minuscules, mais ajouter un petit élément à une liste de tâches et le revisiter plus tard prend souvent beaucoup plus de temps que de le corriger immédiatement.

Comment gérez-vous de telles situations?

Je pense que vous devez être très pragmatique lors de la programmation. Même s'il est possible de formuler le schéma, le flux de travail ou la mise en œuvre parfaits, il suffit parfois de faire le travail. Voici ce que je fais:

J'utilise la capacité de git pour mettre en scène / valider des morceaux et des lignes individuels, dans la mesure du possible, pour séparer les modifications non liées, bien que cela puisse occasionnellement introduire des problèmes temporaires, si la séparation n'a pas été effectuée correctement. Étant donné que les modifications seront adjacentes, ce n'est généralement pas un problème majeur, sauf si vous avez une politique de test de chaque modification individuelle dans votre pipeline CI.

Lorsque le changement non lié est trop important, je le mettrai sur une liste de tâches et le prendrai généralement juste après, tout en étant frais dans ma tête. Parfois, cela peut prendre un jour ou deux avant que je puisse y revenir, cela dépend de ma tâche actuelle et de mon courant de pensée. Parfois, je vais simplement mettre un TODO: à côté du code incriminé, si je n'ai pas une bonne solution prête.

Il arrive que ce n'est tout simplement pas pratique de séparer les choses et je vais commettre l'ajustement mineur avec le travail original.

La taille du changement est généralement le facteur déterminant lorsque je choisis l'itinéraire à suivre, mais au final, je préfère de loin ignorer une règle de workflow, plutôt que de laisser une odeur derrière.

Mon éditeur dispose d'un plugin qui facilite extrêmement la mise en scène de parties individuelles d'un fichier. J'imagine que d'autres éditeurs de programmeurs pourraient avoir des plugins similaires, bien que vous puissiez toujours le faire de manière manuelle avec git add --patch | -p. Ensuite, j'utilise git stash pour enregistrer mes autres modifications afin de tester mon petit commit de manière isolée. Ensuite, après avoir commis, je fais juste un git stash popet continue où je me suis arrêté. C'est précisément pour cela que ces fonctionnalités ont été conçues.

L'astuce n'est pas de faire des changements à moins que vous ne soyez prêt à y consacrer autant d'efforts que le changement le mérite.

Ce que j'ai tendance à faire, c'est d'ajouter à une liste de tâches (parfois en ajoutant des commentaires au code, parfois dans une note sur un ticket de bogue, et parfois en mettant à jour le code dans une branche distincte sachant que le correctif sera éventuellement fusionné). S'il n'y a pas de ticket de bogue pour un cumul de problèmes de qualité mineurs, j'en soulève un spécifiquement pour cela, donc moi et tout le monde pouvons dire quelle était la raison de ces changements de code lorsque la branche est fusionnée. Je ne fais jamais que des changements pour le plaisir, tout est traçable afin que mes collègues ne soient pas trop surpris lorsque le code change.

Donc en bref - oui, ignorez-les lors du codage. Si vous ajoutez une fonctionnalité, ne soyez pas tenté d'ajouter 2 fonctionnalités, aussi petites soient-elles. Si quelqu'un décide de rétablir votre branche (parce que votre fonctionnalité n'est plus requise, disons), vous perdrez également tous vos mini-corrections de bogues. De même, vous ne voulez pas faire un petit «correctif» dans un code critique qui fonctionnait correctement.

Une option que j'utilise un peu est d'ajouter des TODOcommentaires, puis de faire de nombreuses validations "partielles" fréquentes, en utilisant git add --patchpour sélectionner les parties pertinentes du fichier. Ensuite, utilisez git rebase --interactivepour réorganiser et fusionner les validations partielles dans la fonctionnalité finale et les validations de correction avant de les pousser.

Cela maintient votre commit principal propre et vous permet toujours de résoudre immédiatement les autres problèmes que vous rencontrez.

Il n'y a rien de mal à un git rebasedans ce contexte car vous ne faites que réécrire les commits locaux.

Une autre option pourrait être de "git stash" vos modifications actuelles. Le flux de travail ressemblerait à ceci:

1. Commencez à apporter des modifications liées à la fonction A
2. Découvrez le bug B et décidez de le corriger immédiatement
3. À partir de la ligne de commande de votre dépôt, effectuez git stash (après quoi votre code reviendra à l'état dans lequel il se trouvait avant de commencer à travailler sur la fonction A )
4. À ce stade, vos modifications non validées pour la fonctionnalité A sont stockées dans la "cachette"
5. Apportez les modifications de code nécessaires pour corriger le bogue B et effectuez une nouvelle validation dans le référentiel
6. Depuis la ligne de commande, exécutez git stash pop
7. Vos modifications non validées pour la fonctionnalité A sont maintenant retirées de la cachette et restaurées dans votre code en cours à côté du correctif (déjà validé ) pour le bogue B

Mettez en scène (et validez) séparément les modifications liées à la correction de bogue. Dans Git Extensions, cela est extrêmement facile à faire. Depuis la ligne de commande, je pense que vous devez le faire git add -p.