Imaginez que vous créez un lecteur vidéo en JavaScript. Ce lecteur vidéo boucle la vidéo de l'utilisateur de manière répétée à l'aide d'une fonction récursive et, de ce fait, le navigateur en déclenche une too much recursion RangeErrorà un moment donné.

Probablement personne n'utilisera autant la fonction de boucle. Votre application ne générera jamais cette erreur, même si l'utilisateur a laissé l'application en boucle pendant une semaine, mais elle existe toujours. Pour résoudre ce problème, vous devrez repenser le fonctionnement de la mise en boucle dans votre application, ce qui prendra un temps considérable. Que faire? Pourquoi?

• Corriger le bug

• Laisser le bug

Ne devriez-vous pas réparer que les bugs que les gens vont trébucher? Quand les corrections de bugs deviennent-elles excessives, si jamais elles le sont?

MODIFIER:

Si l’approche récursive ne causant pas de bogue vous préoccupe, supposons que chaque fois que le lecteur boucle une vidéo, une variable est augmentée 1. Après 2 ⁵³ boucles, cette variable débordera et votre programme ne pourra pas la gérer, lançant une exception.

Vous devez être pragmatique.

S'il est peu probable que l'erreur se produise dans le monde réel et que le coût de la réparation soit élevé, je doute que de nombreuses personnes y voient un bon usage des ressources à réparer. Sur cette base, je dirais de laisser tomber mais de veiller à ce que le piratage soit documenté pour vous ou votre successeur dans quelques mois (voir le dernier paragraphe).

Cela dit, vous devriez utiliser ce problème comme une "expérience d'apprentissage" et la prochaine fois que vous utiliserez la boucle, n'utilisez pas inutilement une boucle récursive.

Aussi, soyez prêt pour ce rapport de bogue. Vous seriez surpris de voir à quel point les utilisateurs finaux sont capables de repousser les limites et de détecter les défauts. Si cela devient un problème pour les utilisateurs finaux, vous devrez le résoudre - alors vous serez heureux de documenter le piratage.

Un problème similaire dans Windows 95 provoquait le blocage des ordinateurs après 49,7 jours . Cela n'a été remarqué que quelques années après sa publication, car très peu de systèmes Win95 sont restés aussi longtemps actifs. Donc, il y a un point: les bogues peuvent être rendus non pertinents par d'autres bogues plus importants.

Ce que vous devez faire, c'est une évaluation des risques pour le programme dans son ensemble et une évaluation de l'impact de chaque bogue.

• Ce logiciel est-il sur une frontière de sécurité?
• Si oui, ce bogue peut-il donner lieu à un exploit?
• Ce logiciel est-il "critique" pour les utilisateurs auxquels il est destiné? (Voir la liste des choses pour lesquelles le CLUF de Java vous interdit de l'utiliser )
• Le bogue peut-il entraîner une perte de données? Perte financière? Perte de réputation?
• Quelle est la probabilité que ce bug se produise? (Vous avez inclus cela dans votre scénario)

Etc. Cela affecte le tri des bogues , le processus de choix des bogues à corriger. Presque tous les logiciels d’expédition ont une très longue liste de bugs mineurs qui n’ont pas encore été jugés suffisamment importants pour être corrigés.

Les autres réponses sont déjà très bonnes, et je sais que votre exemple n’est qu’un exemple, mais je tiens à souligner une grande partie de ce processus qui n’a pas encore été discutée:

Vous devez identifier vos hypothèses, puis les tester par rapport aux cas critiques.

En regardant votre exemple, je vois quelques hypothèses:

• L'approche récursive finira par provoquer une erreur.
• Personne ne verra cette erreur car la lecture des vidéos prend trop de temps pour atteindre la limite de pile.

D'autres personnes ont discuté de la première hypothèse, mais regardez la deuxième hypothèse: que se passe-t-il si ma vidéo ne dure qu'une fraction de seconde?

Et bien sûr, ce n’est peut-être pas un cas d’utilisation très courant. Mais êtes-vous vraiment sûr que personne ne téléchargera une très courte vidéo? Vous supposez que les vidéos ont une durée minimale et vous n'avez probablement même pas réalisé que vous supposiez quoi que ce soit! Cette hypothèse pourrait-elle causer d'autres bogues à d'autres endroits de votre application?

Les hypothèses non identifiées sont une source énorme de bugs.

Comme je l'ai dit, je sais que votre exemple n'est qu'un exemple, mais le processus d'identification de vos hypothèses (qui est souvent plus difficile qu'il n'y paraît) et le fait de penser à des exceptions à ces hypothèses sont également un facteur déterminant pour décider où passer votre temps.

Donc, si vous vous trouvez en train de penser "je ne devrais pas avoir à programmer autour de ça, car cela n'arrivera jamais", alors vous devriez prendre un peu de temps pour vraiment examiner cette hypothèse. Vous penserez souvent à des cas particuliers qui pourraient être plus courants que vous ne le pensiez au départ.

Cela étant dit, il y a un moment où cela devient un exercice futile. Vous ne vous souciez probablement pas de savoir si votre application JavaScript fonctionne parfaitement sur une calculatrice TI-89, aussi perdez-vous du temps.

Les autres réponses ont déjà abordé cette question, mais la distinction entre "c'est important" et "c'est une perte de temps" n'est pas une science exacte, elle dépend de nombreux facteurs qui peuvent être complètement différents personne ou entreprise à une autre.

Mais une partie importante de ce processus consiste d'abord à identifier vos hypothèses, puis à reconnaître les exceptions à ces hypothèses.

Je vous recommande de lire le document suivant:

La fiabilité et ses menaces: une taxonomie

Il décrit entre autres divers types de défauts pouvant survenir dans votre programme. Ce que vous avez décrit s'appelle une faute dormante et est décrit comme suit dans cet article:

Un défaut est actif lorsqu'il produit une erreur, sinon il est en sommeil. Une défaillance active est soit a) une défaillance interne qui était auparavant dormante et qui a été activée par le processus de calcul ou les conditions environnementales, ou b) une défaillance externe. L'activation de défaut est l'application d'une entrée (le modèle d'activation) à un composant qui active un défaut en sommeil. La plupart des défauts internes alternent entre leurs états dormant et actif

Cela dit, tout se résume à un rapport coûts-avantages. Le coût serait composé de trois paramètres:

• À quelle fréquence le problème se présenterait-il?
• Quelles seraient les conséquences?
• Combien cela vous dérange personnellement?

Les deux premiers sont cruciaux. Si c'est un bogue qui se manifeste une fois dans une lune bleue et / ou que personne ne s'en soucie, ou si une solution de contournement parfaitement pratique est en place, vous pouvez le documenter en toute sécurité en tant que problème connu et passer à un problème plus stimulant et plus complexe. tâches importantes. Cependant, si le bogue entraînait l'échec d'une transaction monétaire ou interrompait un long processus d'enregistrement, frustrant ainsi l'utilisateur final, vous devez agir en conséquence. Le troisième paramètre est quelque chose que je déconseille fortement. Dans les mots de Vito Corleone:

Ce n'est pas personnel. C'est des affaires.

Si vous êtes un professionnel, laissez les émotions de côté et agissez de manière optimale. Cependant, si l'application que vous écrivez est un loisir, alors vous êtes impliqué émotionnellement et le troisième paramètre est aussi valide que possible pour décider de corriger un bogue ou non.

Ce bug ne reste inconnu que le jour où quelqu'un place votre joueur sur un écran d'accueil dans une présentation de société 24h / 24 et 7j / 7. Donc c'est toujours un bug.

La réponse à Que faites-vous? est vraiment une décision d’affaires, pas une décision d’ingénierie:

• Si le bogue ne concerne que 1% de vos utilisateurs et que votre lecteur ne prend pas en charge une fonctionnalité requise par 20% supplémentaires, le choix est évident. Documentez le bug, puis continuez.
• Si le correctif est sur votre liste de tâches, il est souvent préférable de le corriger avant de commencer à ajouter de nouvelles fonctionnalités. Vous bénéficierez des avantages du processus de développement logiciel zéro défaut et vous ne perdrez pas beaucoup de temps car il figure de toute façon sur votre liste.

Surtout dans les grandes entreprises (ou les grands projets), il existe un moyen très pragmatique d'établir ce qu'il faut faire.

Si le coût de la réparation est supérieur au retour que la correction apportera, conservez le bogue. Viceversa, si le correctif retourne plus que son coût, corrigez le bogue.

Dans votre exemple de scénario, cela dépend du nombre d'utilisateurs que vous prévoyez perdre par rapport au nombre d'utilisateurs que vous gagnerez si vous développez de nouvelles fonctionnalités au lieu de corriger ce bug coûteux.

C'est pourquoi RESOLVED/WONTFIXc'est une chose. Il suffit de ne pas en abuser - la dette technique peut s'accumuler si vous ne faites pas attention. S'agit-il d'un problème fondamental dans votre conception, susceptible de causer d'autres problèmes à l'avenir? Alors corrige-le. Autrement? Laissez-le jusqu'à ce que cela devienne une priorité (si cela se produit).

Vous décrivez en réalité trois erreurs dans la situation:

1. L'absence de processus permettant d'évaluer toutes les erreurs consignées (vous avez bien consigné l'erreur dans votre ticket / backlog / quel que soit le système en place, n'est-ce pas?) Pour déterminer si elle doit être corrigée ou non. C'est une décision de gestion.

2. Le manque de compétences de votre équipe conduit à l’utilisation de solutions défectueuses comme celle-ci. Il est urgent de régler ce problème pour éviter des problèmes futurs. (Commencez à apprendre de vos erreurs.)

3. Le problème que la vidéo peut cesser d’afficher après une très longue période.

Des trois erreurs seulement (3) pourrait ne pas avoir besoin d'être corrigé.

Il y a beaucoup de réponses ici en discutant de l'évaluation du coût de la résolution du bogue plutôt que de son départ. Ils contiennent tous de bons conseils, mais j'aimerais ajouter que le coût d'un bogue est souvent sous-estimé, voire très largement sous-estimé. La raison en est que les insectes existants embrouillent les eaux pour un développement et une maintenance continus. Faire en sorte que vos testeurs gardent une trace de plusieurs bogues "ne résolvent pas" tout en naviguant dans votre logiciel pour essayer de trouver de nouveaux bogues rendant leur travail plus lent et plus sujet aux erreurs. Quelques bugs "qui ne résoudront pas" qui n'affecteront probablement pas les utilisateurs finaux ralentiront encore le développement et le résultat sera encore plus gênant.

Une chose que j’ai apprise au cours de mes années de codage est qu’un bogue reviendra. L'utilisateur final le trouvera toujours et en rendra compte. Que vous corrigiez ou non le bogue est "simplement" une priorité et que les délais sont importants.

Nous avons eu des bugs majeurs (à mon avis majeurs) qui ont été décidés contre la correction dans une version, pour devenir un obstacle pour la prochaine version car l'utilisateur final est tombé dessus à maintes reprises. Le même vice-versa - nous avons été poussés à résoudre un bogue dans une fonctionnalité que personne n'utilise, mais il était pratique pour la gestion de voir.

Il y a trois choses ici:

Des principes

C'est un côté de la médaille. Dans une certaine mesure, j'estime qu'il est bon d'insister sur la correction des bogues (ou des mauvaises implémentations, même si elles "fonctionnent"), même si personne ne s'en aperçoit.

Regardez-le comme suit: dans votre exemple, le vrai problème n'est pas nécessairement le bogue, mais le fait qu'un programmeur pense que c'est une bonne idée d'implémenter la boucle de cette manière. Dès le premier instant, il était évident que ce n'était pas une bonne solution. Il y a maintenant deux possibilités:

• Le programmeur n'a tout simplement pas remarqué. Eh bien ... un programmeur devrait développer une intuition sur le fonctionnement de son code. Ce n'est pas comme si la récursivité est un concept très difficile. En corrigeant le bogue (et en transpirant avec tout le travail supplémentaire), il apprend peut-être quelque chose et s'en souvient, ne serait-ce que pour éviter le travail supplémentaire à venir. Si la raison était qu'il tout simplement pas eu assez de temps, la direction peut apprendre que les programmeurs ne ont besoin de plus de temps pour créer un code de meilleure qualité.

• Le programmeur l'a remarqué, mais l'a jugé "pas un problème". Si cela est laissé de côté, alors une culture de laisser-faire est développée qui finira par conduire à des bugs là où ça fait vraiment mal. Dans ce cas particulier, peu importe. Mais que se passe-t-il si le programmeur développe une application bancaire la prochaine fois et décide qu’une certaine constellation ne se produira jamais? Alors ça le fait. Mauvais moments.

Pragmatisme

Ceci est l'autre côté. Bien entendu , dans ce cas particulier, le problème ne serait probablement pas résolu. Mais attention, il y a du pragmatisme, puis du pragmatisme. Un bon pragmatisme suppose que vous trouviez une solution rapide, mais néanmoins solide et bien fondée, à un problème. En d'autres termes, vous évitez de trop dessiner, mais les éléments que vous implémentez sont toujours bien pensés. Le mauvais pragmatisme, c’est quand vous venez de pirater quelque chose qui fonctionne "exactement" et qui va casser à la première occasion.

Échouer vite, échouer dur

En cas de doute, échouez vite et fort.

Cela signifie, entre autres, que votre code remarque la condition d'erreur, pas l'environnement.

Dans cet exemple, le moins que vous puissiez faire est de faire en sorte que l'erreur d'exécution dure ("profondeur de la pile dépassée" ou quelque chose du genre) ne se produise pas, en la remplaçant par une exception matérielle de votre cru. Vous pouvez, par exemple, avoir un compteur global et décider de manière arbitraire que vous renflouez après 1 000 vidéos (ou un nombre suffisamment élevé pour ne jamais apparaître en utilisation normale et suffisamment bas pour fonctionner dans la plupart des navigateurs). Donnez ensuite à cette exception (qui peut être une exception générique, par exemple RuntimeExceptionen Java, ou une simple chaîne en JavaScript ou Ruby) un message explicite. Vous n'êtes pas obligé d'aller jusqu'à créer un nouveau type d'exceptions ou quoi que vous fassiez dans votre langage de programmation.

De cette façon, vous avez

• ... documenté le problème à l'intérieur du code.
• ... En fait un problème déterministe. Vous savez que votre exception se produira. Vous n'êtes pas à la merci des modifications de la technologie du navigateur sous-jacent (pensez non seulement au navigateur PC, mais aussi aux smartphones, tablettes ou technologies futures).
• ... il est facile de le réparer quand vous avez finalement besoin de le réparer. Votre message indique la source du problème, vous obtiendrez un retour en arrière significatif et tout le reste.
• ... toujours pas de perte de temps à gérer les erreurs "réelles" (rappelez-vous, vous ne vous attendez jamais à ce que l'erreur se produise).

Ma convention est de préfixer de tels messages d'erreur avec le mot "Paranoia:". Ceci est un signe clair pour moi et pour tous les autres que je ne m'attends jamais à ce que cette erreur se produise. Je peux clairement les séparer des "vraies" exceptions. Si j'en vois un comme celui-ci dans une interface graphique ou un fichier journal, je sais que j'ai un problème sérieux - je ne m'attendais pas à ce qu'il se produise, après tout. À ce stade, je passe en mode crunch (avec une bonne chance de le résoudre rapidement et assez facilement, car je sais exactement où le problème s'est produit, ce qui m'a évité beaucoup de débogage parasite).

Un post-it sur le bureau d'un développeur senior sur mon lieu de travail dit

Est-ce que ça aide quelqu'un?

Je pense que c'est souvent un bon point de départ pour le processus de réflexion. Il y a toujours beaucoup de choses à réparer et à améliorer - mais quelle valeur ajoutez-vous réellement? ... que ce soit en termes de facilité d'utilisation, de fiabilité, de maintenabilité, de lisibilité, de performance ... ou de tout autre aspect.

Trois choses me viennent à l’esprit:

Premièrement , l'impact d'un bogue identifié doit faire l'objet d' une analyse approfondie avant que la décision de laisser le bogue dans le code puisse être prise de manière responsable. (Dans votre exemple, j'ai tout de suite pensé à la fuite de mémoire représentée par la pile sans cesse croissante et susceptible de ralentir votre navigateur à chaque récursivité.) Cette enquête approfondie prend souvent plus de temps que de corriger le bogue, je préfère donc corriger le bug dans la plupart des cas.

Deuxièmement , les bugs ont tendance à avoir plus d’impact qu’on ne le pense au début. Nous connaissons tous très bien le code de travail car il s'agit du cas "normal". Les bugs par contre sont une "exception". Bien sûr, nous avons tous vu beaucoup de bugs, mais nous avons vu beaucoup plus de code fonctionner. Nous avons donc plus d'expérience sur le comportement du code de travail que sur le comportement du code buggy. Il existe de nombreux livres sur le code de travail et sur ce qu’il fera dans quelles situations. Le comportement du code buggy est pratiquement inexistant.

La raison en est simple: les insectes ne sont pas un ordre, mais un chaos . Ils ont souvent une trace d'ordre en eux (ou l'inverse: ils ne détruisent pas complètement l'ordre), mais leur nature buggée est une destruction de l'ordre recherché par le programmeur. Le chaos lui-même a tendance à ne pas être estimé correctement. Il est beaucoup plus difficile de dire ce qu'un programme avec un bogue va faire que ce qu'un programme correct fera juste parce qu'il ne correspond plus à nos schémas mentaux.

Troisièmement , votre exemple contenait l’aspect que la correction du bogue impliquerait de repenser le programme. (Si vous supprimez cet aspect, la réponse est simple: corrigez le bogue, cela ne devrait pas prendre trop de temps, car aucune refonte n'est nécessaire. Dans le cas contraire :), dans ce cas, je ne ferais plus confiance au programme tel qu'il est conçu. La refonte serait un moyen de restaurer cette confiance.

Cela dit , les programmes sont des choses que les gens utilisent, et une fonctionnalité manquante ou un deuxième bogue vraiment encombrant ailleurs peut avoir la priorité sur la résolution de votre bogue. Bien sûr, prenez ensuite le chemin pragmatique et faites d’autres choses d’abord. Mais n'oubliez jamais qu'une première estimation rapide de l'impact d'un bogue peut être totalement fausse.

Probabilité faible / conséquences faibles = solution prioritaire faible

• Si la probabilité d'occurrence est très faible
• Si les conséquences de l'occurrence sont légères
• Ensuite, le bogue ne constitue pas une menace, il ne s'agit donc pas d'un correctif prioritaire.

Mais cela ne peut pas devenir une béquille pour les développeurs paresseux ...

• Qu'est-ce que "très basse ocurrence" signifie même?
• Quelles sont les "conséquences légères" même?

Pour énoncer que la probabilité d'occurrence est très faible et que les conséquences sont légères, l'équipe de développement doit comprendre le code, les habitudes d'utilisation et la sécurité.

La plupart des développeurs s’étonnent que les choses qu’ils pensaient à l’origine ne se produiront jamais, mais se produisent souvent.

Notre système éducatif n'enseigne pas très bien les probabilités et la logique. La plupart des personnes, y compris la plupart des ingénieurs en logiciel, ont une logique et une intuition brisées en matière de rentabilité. L'expérience des problèmes du monde réel et des simulations approfondies sont le seul moyen que je connaisse pour résoudre ce problème.

Confrontez votre intuition avec des données du monde réel

Il est important de créer plusieurs journaux pour pouvoir suivre les modèles d'utilisation. Remplissez le code avec des affirmations de choses qui, selon vous, ne devraient pas se produire. Vous serez surpris qu'ils le font. De cette façon, vous pourrez confronter votre intuition avec des données précises et les affiner.

Mon exemple d'un problème bénin et d'une mesure de contrôle

Dans un site de commerce électronique sur lequel j’ai travaillé il y a longtemps, un autre programmeur a commis une erreur: dans des conditions obscures, le système a débité le client de un cent de moins que ce qui était inscrit dans les journaux. J'ai découvert le bogue parce que j'ai établi des rapports pour identifier les différences entre les journaux et les soldes de compte afin de rendre le système comptable plus résistant. Je n'ai jamais corrigé ce bug car la différence était minime. La différence était calculée quotidiennement et était inférieure à 2,00 USD par mois. Il se trouve que nous avons mis au point un tout nouveau système qui, dans un an, devrait remplacer le système actuel. Il ne sert à rien de détourner des ressources d'un projet potentiellement rentable pour réparer quelque chose qui coûte 2,00 USD par mois et qui est soumis à une mesure de contrôle appropriée.

Conclusion

Oui, il y a des bogues qu'il n'est pas nécessaire de corriger tout de suite, qui ne sont pas assez importants pour retarder le développement de nouvelles fonctionnalités. Cependant, le système doit pouvoir contrôler l’occurrence de ce bogue pour s’assurer qu’il est petit, car nous ne pouvons pas faire confiance à notre propre intuition.

Je pense que cela pose la mauvaise question dès le départ.

La question n'est pas "dois-je corriger ce bogue ou ne dois-je pas le réparer". Tout développeur a une quantité de temps limitée. La question est donc "quelle est la chose la plus utile que je puisse faire en une heure, quatre heures ou une semaine".

Si corriger ce bogue est la chose la plus utile à faire, car cela améliore considérablement le logiciel pour la plupart des gens, alors corrigez le bogue. Si vous pouviez apporter des améliorations plus importantes ailleurs, en ajoutant des fonctionnalités qui manquent aux utilisateurs ou en corrigeant un bug plus important, procédez comme suit. Et des points bonus supplémentaires pour tout ce qui rend votre développement futur plus efficace.

La correction des bogues est toujours une surexploitation

Classons la partie bogue en premier.

Est-ce une erreur honnête , par exemple une erreur ponctuelle ou une ombrage variable qui échappe aux tests? Dans ce cas, j’espère bien qu’en plus de "résoudre" le problème, vous avez également écrit de nouveaux tests unitaires, vous en avez profité pour refactoriser le code le plus proche, où tout ce travail est utile .

Si, toutefois, il s’agit d’un défaut de conception, comme dans votre cas, vous devez réévaluer la conception ou, dans le pire des cas, désactiver cette fonction.

Alors, s'il vous plaît, n'essayez pas de le réparer .

Vous pourriez faire pire, bien sûr, vous pourriez essayer une méthodologie de piratage par piratage . La vidéo en boucle est un hack (mauvaise architecture et il y a rupture connue). Vous pouvez ajouter une limite de boucle afin que, après N itérations (que vous avez testées, soit inférieure à la limite du navigateur), la boucle se termine.

Les ramifications sont évidentes, vous devez maintenant supporter à la fois le code erroné et la nouvelle limite de boucle.

PS excuse pour la vue extrême.

PPS Une remarque sur la terminologie: vous ne pouvez pas "réparer" un bogue. Un vétérinaire pourrait peut-être, mais n'y allons pas ;-). Les problèmes sont résolus ou "corrigés", tandis que les bogues sont supprimés ou corrigés.