Correction d'un bogue en travaillant sur une autre partie de la base de code

Cela m'est arrivé au moins une fois. Je travaille sur une partie de la base de code et trouve un petit bogue dans une autre partie, et le bogue m'empêche de terminer ce que j'essaie actuellement de faire. La correction du bogue peut être aussi simple que la modification d'une seule instruction.

Que faites-vous dans cette situation?

1. Corrigez le bogue et validez-le avec votre travail actuel
2. Enregistrez votre travail actuel ailleurs, corrigez le bogue dans un commit séparé, puis continuez votre travail [1]
3. Continuez ce que vous êtes censé faire, validez le code (même s'il brise la construction échoue à certains tests), puis corrigez le bogue (et la construction faire passer les tests) dans un commit séparé

[1] En pratique, cela signifierait: cloner le référentiel d'origine ailleurs, corriger le bogue, valider / pousser les modifications, tirer le commit vers le référentiel sur lequel vous travaillez, fusionner les modifications et continuer votre travail.

Edit: j'ai changé le numéro trois pour refléter ce que je voulais vraiment dire.

J'ai fait 1 et 2 et à la fin, je pense que je préfère le n ° 2. Il permet une meilleure visibilité du correctif de bogue, ce qui peut être important pour le contrôle qualité / les notes de publication / autres développeurs.

Je suis également tombé sur une situation où ce que je pensais être un bug n'était pas réellement (ne pas dire que c'est le cas ici), et le "corriger" dans un commit séparé a permis à un autre développeur de me contacter et d'expliquer ce qui était quoi au lieu du "correctif" qui se perd juste lors de mon enregistrement normal.

Je préfère généralement le n ° 2. Cela rend le référentiel plus propre et rend les journaux plus compréhensibles. Je déteste quand d'autres développeurs avec lesquels je travaille valident 15 corrections de bogues, fonctionnalités et refactorings différents dans le même commit.

En outre, selon la façon dont votre équipe effectue le suivi des défauts, vous devrez peut-être rechercher le référentiel de défauts pour vous assurer que si le défaut que vous corrigez est là, vous marquez l'élément comme terminé. Ou, vous devrez peut-être créer un nouvel élément et le marquer comme terminé pour que le système de défauts et le dépôt de code correspondent.

Je fais # 2. L'utilisation d'outils comme git rend trivial le fractionnement en plusieurs validations. Si vous ne pouvez pas convaincre votre équipe de passer à des outils plus modernes, git-svn vous donnera une portion décente de ce que vous utiliseriez pour résoudre ce problème. Cet article de blog donne un bon aperçu du flux de travail que vous essayez de résoudre: The Thing About Git

Je choisis l'option non écrite (4): divisez votre projet en assemblys / bibliothèques hautement spécialisés, afin que les bogues non liés soient toujours dans un emplacement différent dans l'arborescence de contrôle de version.

Je m'excuse si ce qui précède semble sarcastique, mais je le pense sincèrement. Je grince des dents chaque fois que je vois un projet monolithique avec une centaine de formes et d'espaces de noms qui n'ont rien à voir les uns avec les autres. Je faisais souvent face à ce même dilemme, me demandant si et comment je devais rompre les engagements qui concernaient différents domaines fonctionnels; ce n'est que bien plus tard que j'ai réalisé que le fait d'avoir tous ces différents domaines fonctionnels dans un même projet engageable était, en soi, un gros défaut de conception.

Je trouve encore fréquemment des bogues totalement indépendants lorsque je travaille sur une fonctionnalité spécifique. Je travaille peut-être sur l'interface utilisateur et trouve un bogue dans une logique métier, et je dois le corriger avant de pouvoir continuer. La différence est que la logique métier est toujours dans un assemblage / projet différent de l'interface utilisateur, donc tout ce que j'ai à faire est d'apporter une modification très mineure au BL et de procéder à une validation très mineure, puis de continuer à travailler.

Avoir une très bonne organisation de projet rend non seulement possible, mais assez facile à gérer ces problèmes sans enterrer un changement, casser la construction ou s'embourber dans une branche / fusion irritante (même si vous utilisez un DVCS, ce n'est pas totalement indolore ).

Si vous ne disposez pas de cette option - c'est-à-dire que vous êtes un développeur junior sans aucun mot à dire dans l'organisation du projet - alors j'irais simplement avec # 1 et prendrais les notes appropriées dans le journal pour que les autres personnes sachent pourquoi vous avez fait ce que vous avez fait. Si vous avez apporté un changement majeur, déposez également un rapport de bogue dans votre système de suivi des problèmes pour donner une visibilité sur ce que vous avez résolu et pourquoi.

J'essaie de faire # 2. S'il s'agit vraiment d'un problème distinct, il est fort probable qu'il se trouve dans un fichier différent de celui sur lequel vous travaillez. Vous devriez pouvoir archiver le fichier en tant que validation distincte, même s'il est créé dans le même référentiel que celui sur lequel vous travaillez. Pour toutes les raisons déjà mentionnées, il est tout à fait logique d'avoir des validations aussi indépendantes que possible, pour suivre et annuler le changement s'il est erroné.

En général, je corrige simplement le bogue, puis je continue ce sur quoi je travaillais. Quand il est temps de valider, en supposant que la correction de bogue se trouve dans un fichier séparé, je fais deux validations simultanées - la première est une validation partielle contenant uniquement la correction de bogue, et la seconde est tout le reste.

Réponse courte: # 2. Vous voulez vraiment que ce correctif (avec sa note dans votre tracker!) Soit marqué dans votre historique de version en tant qu'entité distincte.

Réponse plus longue:

• Trébucher sur le bug
• Écrivez un test ou plus démontrant le bug
• Faire passer le test
• Validez juste ce changement et ses tests ( git add --interactiveou darcs record -iou comme votre VCS le fait) (*)
• Reviens à ce que je faisais.

(*) Dans CVS (non, vraiment) j'ai parfois un arbre propre extrait ainsi qu'une copie sur laquelle je travaille. Ensuite, j'utilise une fusion - winmerge, dans mon cas - pour extraire uniquement le correctif dans l'arborescence propre afin que je puisse le valider séparément. (L'autre option consiste à renommer vos fichiers modifiés cvs updateet à les fusionner. Lorsque vous avez validé la modification, supprimez le fichier et renommez vos fichiers déplacés à leur nom d'origine.)

Quelque chose à noter cependant, c'est que je ne trouve généralement que des bogues qui sont liés à ce sur quoi je travaille, ou qui sont à proximité lexicale. Je serais surpris s'il était normal que les gens trouvent des bogues dans des parties non liées de la base de code - pourquoi lisez-vous du code non lié lors de la correction du bogue? (Oui, c'est exactement le contraire de ce que dit Aaronnaught!)

Je corrige le bogue et je fais des commits séparés , un pour chaque correction / fonctionnalité.

La plupart du temps, les modifications ne sont pas dans le même fichier, il est donc facile de séparer les validations. Si les changements se trouvent dans le même fichier, j'utilise TortoiseHg (un frontal graphique GUI) pour sélectionner précisément les différences que je veux valider (je pense qu'il est possible de le faire sur la ligne de commande avec l' extension Record , mais c'est moins pratique ).

Certaines personnes utilisent les files d' attente Mercurial pour isoler les correctifs mineurs tout en travaillant sur une fonctionnalité. Les correctifs mineurs sont empilés dans le MQ et lorsque la fonctionnalité est terminée et validée, le contenu de la file d'attente est également validé (un ensemble de modifications pour chaque entrée de la file d'attente).

Je fais habituellement # 2. Sauvegarder mon travail actuel ailleurs: cela fonctionne généralement bien en créant un patch. De plus, certains IDE (IntelliJ) permettent des changements de rayonnage, c'est exactement cela: enregistrez le travail en cours ailleurs.

Ce que je fais dépend si le bogue est vraiment dans une partie différente. Si c'est le cas, l'enregistrement est indépendant de mes modifications à moitié effectuées. Je fais le changement, je construis cette partie différente pour être sûr que je n'ai pas fait d'erreur triviale, je la teste (peut-être en faisant tout ce qui m'empêche de faire) et je vérifie en expliquant ce qui se passait. Souvent, je crée un élément de travail pour celui-ci, et après l'enregistrement / résolution, attribue le WI à un testeur. Je reviens ensuite à ce que je faisais.

Si tout est rempli de fichiers que j'ai à moitié modifiés, je ne peux pas créer et tester cette partie indépendamment. Dans ce cas, je crée un autre WI pour cela et lorsque je vérifie mes modifications, je résous les deux WI avec le même enregistrement, ce qui est généralement contraire à mes principes, mais s'applique bien dans ce cas.

Dans les deux cas, le correctif finit par être testé par moi, vérifié avec une sorte de piste pour que les gens comprennent pourquoi j'ai changé ce code au hasard ce jour-là, et un WI est attribué à quelqu'un d'autre pour confirmer qu'il est correct maintenant.

Nous faisons # 1. # 2 sonne bien, mais je ne peux pas dire que nous avons eu des problèmes avec # 1 que # 2 résoudrait.

Un facteur supplémentaire dans mon entreprise est que nous créons des applications Web, et nos tests se font presque entièrement via l'interface Web - à peu près, ce que les gens appellent les tests fonctionnels plutôt que les tests unitaires. Tous les tests sont réussis avant l'enregistrement. La division des validations en bits plus petits signifierait exécuter les tests une fois pour chaque bit, ce qui prendrait plus de temps. J'aimerais avoir une suite de tests beaucoup plus rapide, ce qui nous permettrait de faire des commits plus petits, mais nous ne l'avons tout simplement pas.