Les développeurs doivent-ils saisir des bogues dans le système de suivi des bogues?

En développant (que ce soit des fonctionnalités ou des corrections de bugs), il m'arrive parfois de découvrir des bugs qui ne sont pas directement liés à ce sur quoi je travaille. Que devrais-je faire dans cette situation? Juste le réparer? Essayez de vous rappeler de le réparer plus tard? L'écrire quelque part? Ou entrez-le dans le système de suivi des bogues?

En général, je le saisis dans le système de suivi des bogues et laisse le processus s’exercer (triage, attribution, etc.). Cependant, j'ai rarement vu un autre développeur entrer un bogue. (Pourquoi donc?)

Si vous découvrez un bogue, je ne vois aucune bonne raison de ne pas le saisir dans le système de suivi des bogues, que vous le corrigiez ou non. C'est à cela que sert le système de suivi des bogues, après tout.

Dans certains cas, il serait peut-être plus judicieux de le signaler à une personne chargée de l'assurance qualité qui a plus d'expérience dans l'utilisation du système, mais dans tous les cas, le bogue doit être suivi.

Il est possible qu'il y ait une raison, valable ou non, que les développeurs ne doivent pas entrer de bogues. Une des raisons possibles pourrait être que le système de suivi des bogues est visible par les étrangers et qu’un trop grand nombre de bogues signalés est mauvais. C'est une très mauvaise raison, qui devrait être traitée d'une autre manière permettant de suivre les bogues. Demandez à votre patron.

(Bien sûr, s'il y a un bogue dans le code sur lequel vous êtes toujours en train de travailler, et qu'il ne figure pas dans tout ce qui a été publié, il n'est pas nécessaire de le suivre dans le système, bien qu'un commentaire TODO dans le code source puisse être Pour prendre un cas extrême, "Ce code ne compilera pas car je n’ai pas encore saisi le point-virgule à la fin de cette ligne" n’est pas un bug à signaler).

Pour ce qui est de savoir pourquoi les autres développeurs n'entrent pas dans les bogues, vous devrez leur demander. Ils devraient probablement.

Vous devez entrer les bogues dans le système de suivi des bogues dans les deux cas:

• quand le bug concerne directement le code sur lequel vous travaillez,

• lorsque le bogue concerne le code sur lequel vous ne travaillez pas actuellement ou la partie sur laquelle travaille un autre développeur.

Ceci est essentiel, car le système de suivi des bogues est conçu pour ... suivre les bogues. Chaque bug. Si vous découvrez que quelque chose ne va pas, ne vous contentez pas de le réparer. Documentez-le via un système de suivi des bogues. Lorsque plus tard, un client exécutant une version précédente du logiciel signalera un bogue qui est une copie exacte, vous pourrez le lier à votre rapport. Si vous n'avez aucun lien vers lequel vous souhaitez créer un lien, vous perdrez votre temps (ou votre collègue) à rechercher le bogue dans les révisions précédentes, puis à essayer de le résoudre, et vous découvrirez enfin que le bogue a déjà été résolu comme par magie.

Cela explique également pourquoi les pigistes doivent utiliser à la fois le contrôle de version et le système de suivi des bogues: ces deux outils ne sont pas uniquement destinés aux équipes.

Il n'y a aucune raison valable de ne pas introduire un défaut dans le système de suivi des défauts. Les seuls endroits où j'ai vu des corrections de bugs appliquées sans suivi sont dus au fait que le processus était fondamentalement en panne. Si tel est le cas, corrigez le processus.

les raisons pour ne pas entrer sont:

• Le processus mesure et punit en fonction du signalement des défauts - ne signalez pas, ne soyez pas puni. Dans ce cas, quitter l'organisation
• Le processus est un fardeau - il faut trop d’efforts et de temps pour saisir un défaut et arriver au point de le réparer. Le processus doit être modifié pour permettre aux développeurs d’accélérer le traitement d’un bogue léger dans le processus de triage / acceptation / correction.
• Certains développeurs sont des fainéants / négligés / des hackers qui se moquent de l’impact de ce qu’ils font sur les autres. Recruter des développeurs professionnels.
• Je suis un groupe d'hommes, ne vois pas le point. Allez travailler pour un groupe de 2 hommes et vous ....

Corriger le bogue immédiatement est probablement une mauvaise idée. Tout d’abord, il se peut que quelqu'un travaille sur le même correctif, ce qui entraîne des efforts redondants, puis, selon la méthodologie de développement que vous suivez, définir les priorités sur lesquelles travailler ensuite (correction d’un bogue ou implémentation d’une nouvelle fonctionnalité) est plus qu'une priorité. décision de gestion puis décision de développement.

La décision n'est pas claire et implique des compromis.

(certains) PROS

Le suivi des bogues est essentiel pour la communication, en particulier sur les grandes équipes. L'un des meilleurs avantages à avoir plusieurs yeux sur le code est la capacité de détecter les problèmes plus tôt, et cet avantage est perdu si les bogues ne sont pas enregistrés ou suivis au cours du développement.

• Souvent, les bogues sont plus facilement corrigés lorsque vous êtes déjà dans une partie du code et que vous travaillez à le comprendre.
• Même pour les petites équipes, il est très avantageux d’avoir la possibilité de lister les bogues et de progresser dans leur correction. Parfois, l’avantage moral est crucial, même pour les projets à un seul homme.
• Une détection de bogue précise peut s'avérer très difficile par la suite - voir un bogue dans le code peut faire économiser beaucoup de travail à un détective ultérieur, en essayant de déterminer la cause initiale du problème.
• Il est bon que votre développement général, en tant que développeur, soit attentif aux bugs tels que vous les voyez et prenez l'habitude d'améliorer / de nettoyer / de lire le code de manière critique.

Consigner les bugs tels que vous les avez trouvés est, en général, une bonne habitude.

(certains) CONS

Saisie de bogues dans un système de suivi des bogues peut être fastidieux et fastidieux, et peut réellement perturber le travail de développement - plus souvent aussi lorsque vous travaillez dans de grandes équipes. Vous pouvez être amené à:

• vérifiez si votre entrée est une copie en double avant d'entrer (ceci pourrait même être implicite, il est décourageant de saisir votre bogue dans la file d'attente uniquement pour le fermer)
• fournir des cas de test répétables pour votre rapport
• accepter des interruptions ultérieures avec des questions sur les détails d'un bogue, pour accepter / vérifier un correctif une fois écrit
• Pensez aux informations non liées qui sont souvent collectées dans les systèmes de suivi des bogues, telles que le produit qui est probablement le plus affecté, la priorité du bogue, etc.

Parfois, le suivi des bogues n’est tout simplement pas l’utilisation la plus efficace de votre temps.

Ce sont deux principes généraux qui peuvent être difficiles à équilibrer - trouver une bonne stratégie est un peu un art. Dans de telles situations, je pense qu'il est préférable d'adopter une heuristique flexible, que je peaufine selon les besoins pour un projet donné, une équipe, un environnement de travail et vos compétences générales. Ma stratégie suit généralement un modèle approximativement comme suit:

• Consignez toujours les problèmes que vous voyez tout au long de la journée, quelque part. Peut-être sur un collant, peut-être dans un fichier sur le côté. Peut-être que tout ce que vous enregistrez est un nom de fichier et un numéro de ligne, peut-être plus. Ne laissez pas le problème interrompre trop votre pensée actuelle.

• Prenez le temps au début de chaque nouvelle journée de travail, dans le cadre de votre échauffement au travail, de vous attaquer aux collants. Je prends de 10 à 15 minutes pour parcourir la liste des problèmes détectés de la veille et effectuer celle qui suit est la plus rapide:

  • Corrigez le problème et validez-le (probablement pour un correctif de doublure ou une faute de frappe). Si vous n'êtes pas autorisé à commettre sans rapport de bogue, créez un projet parallèle pour de petits commits. Lorsque suffisamment de corrections s’accumulent dans le projet secondaire, prenez les quelques heures nécessaires pour les documenter et les valider.
  • Consignez le problème dans un système de suivi des bogues (pour les problèmes évidents dont la résolution est plus longue, mais sans surcharge)
  • Consignez le problème dans un document "à regarder quand il n'est pas occupé" (j'ajoute généralement un commentaire de type "// TODO - cela a l'air cassé, corrigez-le" à la source). Prenez régulièrement une journée (j'essaie une fois par mois) de parcourir la liste et de la consigner, le cas échéant - demande de fonctionnalité, rapport de bogue, discussion avec le responsable, etc.

Au fil du temps, j'ai trouvé toutes sortes d'ajustements utiles. Par exemple:

• Dans des environnements plus rigides, je pourrais simplement confier le travail de rapport de bogue à l'équipe de test. Demandez à un testeur de me rencontrer une heure de temps en temps, donnez-leur la liste des problèmes et demandez-leur de consigner. Dans les environnements où la journalisation des tests est un gros problème, le testeur sera généralement ravi de pouvoir augmenter gratuitement sa productivité.
• Certaines équipes refusent d'autoriser les correctifs pour lesquels il n'existe pas de rapport de bogue client. Je gardais un projet plein de correctifs sur le côté et les engageais instantanément lorsque le problème pertinent était signalé par un client, pour des points gratuits.
• Certaines équipes exigent que la personne "possédant" un morceau de code soit celle qui effectue les correctifs. Je traiterais le code "propriétaire" comme un test lead et me réunirais de manière informelle pour régler des problèmes à l'occasion

Je trouve qu'en général, lorsque vous suivez ce type de stratégie, de plus en plus de pairs et de membres de l'entreprise vont commencer à respecter votre travail et votre engagement envers la qualité. Après suffisamment de temps, vous aurez le respect et l'autorité nécessaires pour optimiser l'ensemble du processus à votre goût. Gardez un œil sur de telles opportunités et prenez-les comme il convient.

Je crois que si un développeur rencontre un bogue qui n’est pas lié à son travail et qu’il ne corrigera pas, il devrait l’entrer dans le système pour en avoir une trace. De cette façon, lorsque le contrôle qualité commence les tests (et qu'ils ne sont toujours pas corrigés), vous pouvez leur attribuer cette liste de bogues comme "défauts connus" afin qu'ils ne commencent pas à signaler les mêmes bogues.

Peut-être que d'autres développeurs qui trouvent des bogues le suivent d'eux-mêmes s'ils prévoient de le réparer, mais dans ce cas, ils risquent 2 développeurs de trouver et de corriger le même bogue de manière indépendante.

J'ajouterais que même si le bogue a déjà été corrigé (ce qui n'aurait pas dû se passer avant de l'enregistrer dans un outil de suivi des problèmes), il est judicieux de le suivre.

De cette façon, si le problème devait se reproduire à l'avenir (des régressions se produisent!), Il est relativement facile de reconnaître le problème comme "déjà traité" et de lire comment il a été résolu la première fois.

Pourquoi donc? Parce que la plupart des développeurs se penchent sur le problème qu’ils doivent soulever et le code qu’ils doivent écrire, il est donc plus facile de ne pas déranger.

Mais, que ce soit la bonne chose à faire dépend de votre processus. Avez-vous une équipe d'assurance qualité? Pensez-vous que cela les dérange si vous changez simplement le code qui ne sera pas suivi? Qu'en est-il des critiques de code? Va-t-il sauter par cette fissure? Qu'en est-il de l'entreprise? Ont-ils besoin de savoir que vous avez corrigé un bogue pour ne pas en créer le même plus tard?

Qu'en est-il des autres développeurs? Que se passe-t-il s'ils le corrigent d'une manière différente en même temps? Et s’ils trouvaient un bogue similaire plus tard et que tout ce que vous pouviez faire, c’était "oh, putain, je sais que nous avons eu quelque chose comme ça avant - maintenant, c’était quoi?"

Il y a environ un million de raisons pour enregistrer des bogues dans le système de suivi des bogues. Si vous êtes SÛR que vous ne rencontrez aucun de ces problèmes, alors, ne vous en faites pas. Mais si vous n'êtes pas du tout sûr, vous devriez l'enregistrer, même si la plupart des gens ne le savent pas.

La programmation est fondamentalement un travail complexe. Les bugs sont complexes. donc j’avais l'habitude d'évaluer un bogue selon deux facteurs:

1. Combien de fois ce type de bugs peut-il apparaître à nouveau dans le futur? Que cette estimation soit exacte ou non, continuez d'estimer.
2. Est-ce que c'est facile à comprendre quand de tels bugs apparaissent à nouveau? Ceci est exact lorsque vous analysez ce bogue et le corrigez.

Je classerais un bogue dans l'un des types suivants:

1. Apparemment à nouveau à l'avenir, et facile à comprendre
2. Apparaître à nouveau à l'avenir, mais difficile à comprendre
3. Apparaît rarement à l'avenir, et facile à comprendre
4. Apparaît rarement à l'avenir, mais difficile à comprendre

Dans le cas 1, un livre de recettes ou une FAQ est un bon moyen pour l’équipe de corriger de tels bugs à l’avenir.

Dans le cas 2, un enregistrement élaboré et compréhensible est nécessaire pour l’équipe car c’est un gaspillage d’efforts si un autre programmeur supporte à nouveau de tels bogues. Par exemple: fuite de mémoire.

Dans le cas 3, je pense que ce n'est pas grave car il ne reste plus rien à enregistrer car vous ne passerez pas trop de temps à corriger un bug simple. Par exemple, une typo pour id d’élément en HTML.

Dans le cas 4, ces bugs créent un dilemme. Il faut un peu de temps pour rédiger un enregistrement élaboré et compréhensible pour décrire ces bugs. Mais cet enregistrement est rarement utilisé à l'avenir. Sans dossier, cependant, l'apparition de tels bugs serait à nouveau une lutte. Par exemple, de tels bogues apparaissent à cause d'un virus informatique dans l'ordinateur de quelqu'un.

Bien sûr, vous devriez y entrer. Ou au moins, signalez-le à votre personnel d'AQ si c'est votre processus habituel.

Même si vous ne corrigez que le bogue vous-même, vous voudrez enregistrer le changement afin qu'il puisse ensuite être testé pour s'assurer que le correctif fonctionne réellement et qu'il n'y a pas eu de régression. Il est également possible qu'un utilisateur signale le bogue à un moment donné, et s'il est dans le système et marqué comme étant résolu, votre support technique peut leur dire qu'il a déjà été corrigé.

En effet, vous devriez les enregistrer dans le système, et si cela n’est pas pratiqué, il est bon de commencer.

Auparavant, je faisais partie d'une équipe produit et nous étions sur la version bêta d'un nouveau produit. Nous rencontrions parfois des bugs que nous avions l'habitude de noter et d'envoyer par courrier aux responsables des modules (nous avions un système de suivi des bogues, mais nous n’avons pas pensé à les y pousser). Plus tard, lorsque les jours passaient, les articles dans le courrier ont commencé à être ignorés en raison d'autres priorités, ce qui a éventuellement conduit à des nuits blanches.

Alors, bang un jour, Nirvana! Pourquoi n'utilisons-nous pas le traqueur de bogues, même si vous avez trouvé quelque chose qui ressemble à un bogue et qui pourrait être possible que ce ne soit pas le cas (votre conception du processus est erronée / défectueuse). Il fait au moins partie de la liste qui pourrait ensuite être testée et le plus important de tous est d' indiquer en quoi c'est essentiel ou du moins c'est parfait et c'est ainsi que cela devrait fonctionner pour des raisons 1 ... 2 ... .

Maintenant, vous avez la liste et aussi pour ceux qui ont mal compris certaines parties de l'application, ils ont un retour d'informations sur lequel ils peuvent clarifier leurs pensées. Une situation gagnant-gagnant.

En supposant que son code déjà testé (et en particulier si publié) absolument.

Il ya un certain nombre de raisons à cela:

Mémoire - Il est très peu probable que le système oublie le bogue, quel que soit le développeur.

Métriques - Le nombre de bogues trouvés, fermés et le temps pris peuvent constituer de bons métriques faciles à capturer pour vous indiquer l'évolution de la qualité de votre code.

Urgence - Cela peut sembler être la chose la plus importante au monde pour le développeur. Toutefois, il est préférable de consacrer plus de temps à la résolution de ce problème pour quelque chose que les utilisateurs finaux souhaitent avant (voir aussi mémoire).

Duplication - Peut-être qu'il a déjà été repéré et est en cours d'examen / réparation par quelqu'un d'autre. Sinon, peut-être a-t-il été dérogé à la règle de l'urgence. Bien sûr, le fait que vous l'ayez retrouvé ne signifie pas simplement que cela ne devrait pas être fait, cela pourrait aussi signifier que (comme cela continue à se produire), il est maintenant plus urgent de le corriger.

Analyse des causes fondamentales - Le bogue le plus simple à résoudre est celui qui n’a jamais existé. L’équipe devrait peut-être examiner ce bogue pour savoir comment il a été conçu. C’est bien non pas pour punir le responsable (cela n’aide en rien) mais pour savoir comment la situation peut être évitée à l’avenir.

Analyse d'impact plus large - Le bogue le moins cher à trouver est celui que vous connaissiez avant de le trouver. En examinant ce bogue (en particulier après avoir effectué une analyse de la cause première), il peut rapidement devenir évident que ce problème pourrait exister ailleurs au code. En conséquence, l’équipe peut choisir de le trouver avant de lever la tête à un moment plus embarrassant.

Le temps consacré à ces tâches (le cas échéant) dépend en grande partie de la maturité et du niveau de qualité du code. L’analyse de la cause fondamentale risque de surcharger une minuscule équipe travaillant sur le code de démonstration, mais une grande équipe de développement critique doit probablement tirer les leçons de manière efficace et efficiente.

Par expérience, il existe deux grandes raisons pour lesquelles les développeurs évitent d’utiliser cet outil:

1. L'outil et / ou le processus de gestion des bogues sont perçus comme trop lourds pour le développement
2. Les développeurs trouvent le défi mental de résoudre le bogue plus intéressant que les éléments sur lesquels ils travaillent actuellement.

Le point 1 implique qu'un système meilleur / plus simple peut être nécessaire; ou bien une justification plus convaincante du système existant pourrait être utile.

Le point 2 devrait constituer un signe d’avertissement utile pour le responsable du développement concernant les attributions actuelles de tâches.

Je suis principalement d'accord avec FrustratedWithFormsDesign mais je pense que c'est encore plus clair si le problème est divisé en deux parties:

• Rapport de bogue.
• Correction de bugs.

Celles-ci sont souvent traitées comme étant les mêmes et leur séparation aidera presque certainement beaucoup.

Ceux-ci peuvent être manipulés avec: Rapport de bogue: - le mettre dans le système, comme tout le monde le dit.

Correction des anomalies: - Chaque semaine ou tous les deux jours (adaptation au calendrier de développement, etc.), tout le monde se réunit pour décider du projet à résoudre, par qui, etc. Tout le monde est sur la même page et peut voir ce qui doit être terminé. En développement agile, il s'agit de la réunion de planification de sprint.

Un bon outil que les gens veulent utiliser fait également une grande différence. J'aime Pivotal Tracker et il a réussi le test 'Outil vraiment utile' lorsque j'ai commencé à l'utiliser pour garder une trace de ce que je voulais faire ou réparer dans mes propres projets privés!

Si vous voyez quelque chose, dites quelque chose!

J'entre même des rapports de bugs sur mes propres modules parce que je ne veux pas interrompre ma tâche en cours. Et je peux m'assurer que toutes les étapes pour reproduire sont incluses :-)

Et c'est encore mieux quand quelqu'un d'autre peut voir que vous avez répertorié quelque chose comme un bogue connu. Ils aiment savoir que quelqu'un d'autre l'a trouvé aussi.

Je pense qu’il s’agit plus d’une question politique que d’une question de meilleure pratique.

• est-ce que l'entrée de bogue blâme sombody?
• Le client peut-il lire les entrées de bogues et s’assurer qu’il existe des erreurs supplémentaires? Est-ce un problème de réputation pour votre entreprise?
• est-ce vraiment un bug ou une fonctionnalité dont vous n'êtes pas au courant?
• qui paiera le correctif?

À mon avis, il est judicieux d’ajouter des bogues non triviaux dans le système de suivi, mais la direction doit décider comment y faire face.

Pour les cas non triviaux, vous ne devriez pas régler le problème sans consulter quelqu'un d'autre pour s'assurer que

• c'est vraiment un bug et non une fonctionnalité
• sombody else peut tester le correctif et s'assurer que le correctif n'introduit pas un nouveau bogue sinon (régression)