Logiciel embarqué taux de défauts

Question

Qu'est-ce que le taux de défauts que je peux attendre dans un C ++ codebase qui est écrit pour un processeur embarqué (DSP), étant donné qu'il n'y a pas eu de tests unitaires, aucune critique de code, aucune analyse de code statique, et que la compilation du projet génère environ 1500 avertissements. Est 5 défauts / 100 lignes de code une estimation raisonnable?

Answer 1

Malgré mon scepticisme de la validité de toute estimation dans ce cas, j'ai trouvé quelques statistiques qui peuvent être pertinents.

cet article , l'auteur cite les chiffres d'un " un grand nombre d'études empiriques », publié dans Les évaluations logiciels, points de repère, et le meilleur pratiques (Jones, 2000) . SIE CMM Niveau 1 , qui sonne comme le niveau de ce code, on peut attendre un taux de défaut de 0,75 point de fonction . Je vous laisse le soin de déterminer comment points de fonction et LOC peuvent concerner votre code - vous aurez probablement besoin d'un noreferrer outil métriques pour effectuer cette analyse.

Steve McConnell au code complet cite un étudier de 11 projets développés par la même équipe, 5 sans revues de code, 6 avec des revues de code. Le taux de défaut pour le code non examiné était de 4,5 pour 100 LOC, et pour la revue était 0,82. Donc, sur cette base, votre estimation semble juste en l'absence de toute autre information. Cependant, je dois assumer un niveau de professionnalisme parmi cette équipe (juste du fait qu'ils ont ressenti le besoin d'effectuer l'étude), et qu'ils ont au moins participé aux mises en garde; votre taux de défaut pourrait être beaucoup plus élevé .

Le point sur les avertissements que certains sont bénins, et certains sont des erreurs (à savoir se traduira par un comportement indésirable du logiciel), si vous les ignorez sur l'hypothèse qu'ils sont tous bénins, vous introduire des erreurs. De plus une volonté deviennent erreurs en maintenance lorsque les autres conditions changent, mais si vous avez déjà choisi d'accepter un avertissement, vous avez pas de défense contre l'introduction de ces erreurs.

Answer 2

Votre question est « est de 5 défauts / 100 lignes de code une estimation raisonnable? » Cette question est extrêmement difficile de répondre, et il est très dépendante de la complexité et codebase code.

Vous avez également mentionné dans un commentaire « pour montrer la direction qu'il ya probablement beaucoup de bugs dans le code de base. » - c'est super, kudos, sur

Pour les yeux figuratives de la direction ouverte, je vous suggère au moins une approche 3 volets:

• prendre les avertissements du compilateur spécifiques, et de montrer comment certains d'entre eux peuvent causer un comportement indéfini / désastreux. Tous les avertissements seront aussi de poids. Par exemple, si vous avez quelqu'un en utilisant un pointeur non initialisé, c'est l'or pur. Si vous avez quelqu'un bourrer une valeur non signée de 16 bits en une valeur de 8 bits non signé, et il peut être démontré que la valeur 16 bits sera toujours <= 255, que l'on ne va pas aider à faire votre cas aussi fortement.
• exécuter un outil d'analyse statique. PC-Lint (ou Flexelint) ne coûte pas cher et offre un bon « pour votre argent ». Il sera presque certainement attraper des choses que le compilateur ne sera pas, et il peut également fonctionner dans toutes les unités de traduction (tout peluches ensemble, même avec 2 ou plusieurs passes) et trouver des bugs plus subtils. Encore une fois, utiliser certains d'entre eux comme des indications.
• exécuter un outil qui donnera d'autres mesures sur la complexité du code, une autre source de bugs. Je vous recommande M Metrics standard de ressources Squared (RSM) qui sera vous donner plus d'informations et des mesures (y compris la complexité du code) que vous pouvez espérer. Lorsque vous dites que la gestion un score de plus de 50 complexité est « essentiellement invérifiable » et vous avez un score de 200 dans une routine, qui devrait ouvrir des yeux.

Un autre point: j'ai besoin dans mes propres compiles groupes, et la sortie de Lint propre aussi. Habituellement, cela peut accomplir seul en écrivant un bon code, mais de temps en temps les avertissements compilateur / charpie doivent être peaufiné pour calmer l'outil pour des choses qui ne sont pas des problèmes (utilisation judicieuse).

Mais le point important que je veux faire est la suivante: être très prudent en allant dans et fixer le compilateur et les avertissements charpie . Il est un objectif admirable, mais vous pouvez aussi briser inadvertantly code de travail et / ou démasquer un comportement non défini qui a accidentellement travaillé dans le code « cassé ». Oui, cela ne se produit vraiment. Donc, faire preuve de prudence.

Enfin, si vous avez un solide ensemble de tests déjà en place, qui vous aideront à déterminer si vous cassez accidentellement quelque chose en refactoring.

Bonne chance!

Answer 3

Jetez un oeil à la qualité du code. Il rapidement vous donner une indication de la quantité de problèmes qui se cachent dans la source. Si la source est laide et prendre beaucoup de temps pour comprendre, il y aura beaucoup de bugs dans le code.

Code bien structuré avec un style cohérent et qui est facile à comprendre vont contenir moins de problèmes. Code montre combien l'effort et songé à ce projet.

Je suppose que si la source contient que de nombreux avertissements, il va être beaucoup de bugs qui se cachent dans le code.

Answer 4

Cela dépend aussi de qui a écrit le code (niveau d'expérience), et la taille de la base de code est.

Je les avertissements en erreurs.

Combien d'erreurs que vous obtenez lorsque vous exécutez un outil d'analyse statique du code?

EDIT

Exécuter cccc et vérifiez la complexité cyclique du McCabe. Il devrait dire la complexité du code, il.

http://sourceforge.net/projects/cccc/

Exécuter d'autres outils d'analyse statique.

Answer 5

Si vous voulez obtenir une estimation du nombre de défauts, de la manière habituelle de estimatation statistique est de sous-échantillonner les données. Je choisirais trois moyennes sous-routines au hasard, et les vérifier soigneusement les bugs (éliminer les avertissements compilateur, exécutez l'outil d'analyse statique, etc.). Si vous trouvez trois bugs dans 100 lignes de code au total sélectionné au hasard, il semble raisonnable qu'une densité similaire de bogues sont dans le reste du code.

Le problème mentionné ici l'introduction de nouveaux bogues est une question importante, mais vous ne reculez pas besoin de vérifier le code modifié dans la branche de production pour exécuter ce test. Je suggère un ensemble complet de tests unitaires avant de modifier les sous-routines, et le nettoyage de tout le code suivi par les tests du système très complet avant de libérer le nouveau code à la production.

Answer 6

Si vous voulez démontrer les avantages des tests unitaires, des revues de code, des outils d'analyse statique, je suggère de faire une étude pilote.

Faites des tests unitaires, des revues de code, et exécuter des outils d'analyse statique sur une partie du code. Montrer la gestion combien de bugs que vous trouvez en utilisant ces méthodes. Il faut espérer que les résultats parlent d'eux-mêmes.

Answer 7

L'article suivant a quelques chiffres basés sur des projets de la vie réelle à laquelle l'analyse statique a été appliquée à: http://www.stsc.hill.af.mil/crosstalk/2003/11/0311German.html

Bien sûr, les critères selon lesquels une anomalie est peut affecter les comptés résultats de façon spectaculaire, ce qui conduit à la grande variation des chiffres indiqués dans le tableau 1. Dans ce tableau, le nombre d'anomalies par mille lignes de code pour les gammes C de 500 (!) à 10 (généré automatiquement).