Comment éviter les pièges de l'analyse statique

Je travaille dans une entreprise qui obtiendrait 11 sur Joel Test - au moins sur papier.

Dans la pratique, cependant, rien ne fonctionne aussi bien que prévu et le projet est sur DEFCON 1 depuis six mois. Maintenant, la plupart de mes pairs sont heureux s'ils peuvent rentrer chez eux à 18 heures - dimanche.

L'une des bonnes pratiques apparemment qui m'ont semblé ne pas fonctionner est l'utilisation d'outils d'analyse statique. Le projet suit à la fois les avertissements gcc -Wall et un outil propriétaire et très coûteux "C / C ++" .

Les avertissements Gcc indiquent le plus souvent des bogues réels (si la plupart du temps sont inoffensifs).

Les outils propriétaires répertorient cependant des éléments tels que les transtypages implicites et la taille d'un littéral de chaîne. Les moulages implicites sont également sur liste noire sur leur livre de styles.

La pratique courante est que les gens sont pressés de fermer chaque avertissement. Notez que cela exclut les avertissements qui sont principalement des faux positifs, ce n'est pas le problème.

Le résultat est:

1. Les gens ajoutent des transtypages de type à chaque valeur r et à chaque argument cachant de véritables asymétries de type problématique dans le processus.
2. Les gens introduisent un bogue ou utilisent une fonction de langage problématique différente (strlen au lieu de sizeof, strncpy au lieu de strcpy, etc.)
3. Les avertissements sont réduits au silence.
4. Les rapports de bogues commencent à rouler.

Le point principal est que le code original fonctionnait et était écrit par des gens qui jouaient en sécurité dans leurs capacités linguistiques alors que les correctifs ne l'étaient pas.

Maintenant, je ne pense pas vraiment que cette entreprise puisse être sauvée. Cependant, j'aimerais savoir s'il existe une meilleure façon, de préférence de travailler, d'utiliser les outils "pro" ou si je dois simplement éviter de les utiliser complètement au cas où ce serait moi qui prendrais la décision à l'avenir.

Une solution qui ne suppose pas que tous les programmeurs sont des génies qui ne peuvent pas se tromper. Parce que bien, s'ils le sont, alors il n'est pas nécessaire d'utiliser les outils en premier lieu.

Dans la pratique, cependant, rien ne fonctionne aussi bien que prévu et le projet est sur DEFCON 1 depuis six mois. Maintenant, la plupart de mes pairs sont heureux s'ils peuvent rentrer chez eux à 18 heures - dimanche.

C'est certainement une bonne partie de votre problème. Un ingénieur logiciel ne peut pas travailler de manière productive pendant plus de 40 heures / semaine. Si vous allez au-delà de cela, vous endommagez sérieusement votre capacité de travail - au point où même travailler 80 heures / semaine apporte très peu de valeur au projet, et parfois, les projets peuvent même régresser parce que l'équipe introduit plus d'erreurs que ils peuvent réparer. Si vous faites 60 heures / semaine ou plus depuis six mois, alors toute votre équipe a besoin d'une bonne longue pause et de revenir à 40 heures / semaine. Vous ne pouvez pas résoudre quoi que ce soit avec une main-d'œuvre qui est à peine capable de dénigrer le clavier, car ils sont tellement surchargés de travail.

Les outils propriétaires répertorient cependant des éléments tels que les transtypages implicites et la taille d'un littéral de chaîne. Les moulages implicites sont également sur liste noire sur leur livre de styles.

Vous devez vraiment soit laisser tomber l'outil entièrement, soit le reconfigurer / le remplacer. Avertir sur chaque distribution implicite est beaucoup trop pour quiconque.

Je travaille dans une entreprise qui obtiendrait 11 sur Joel Test - au moins sur papier.

Ce test est tout simplement légèrement pertinent pour les éditeurs de logiciels. Je ne comprends pas le battage médiatique à ce sujet. Vous pouvez marquer 12 et avoir toujours des programmeurs 100% merde. Les gens comptent beaucoup plus que les outils.

Les outils propriétaires répertorient cependant des éléments tels que les transtypages implicites et la taille d'un littéral de chaîne. Les moulages implicites sont également sur liste noire sur leur livre de styles. La pratique courante est que les gens sont pressés de fermer chaque avertissement. Notez que cela exclut les avertissements qui sont principalement des faux positifs, ce n'est pas le problème.

C'est le plus gros problème avec tous les analyseurs statiques: trop de faux positifs. La seule façon de gérer cela est d' apprendre en détail pourquoi l'outil a été configuré pour donner un avertissement pour un certain problème. Ce n'est qu'alors que vous pouvez faire des hypothèses qualifiées quant à savoir si un avertissement est faux ou non.

Pour le casting spécifique de transtypages implicites, il est là en raison de quelques bogues très courants, subtils et dangereux dans le langage C, causés par les deux règles de promotion de type implicite (moronique) en C. Ils sont officiellement connus comme les règles de promotion entières et les conversions arithmétiques habituelles . Je pense que moins d'un programmeur professionnel sur dix peut expliquer ce que font ces deux règles et ce qu'elles ne font pas. Et pourtant, ces règles sont extrêmement fondamentales et appliquées des milliers de fois entre les lignes de tout programme C normal.

La norme MISRA-C a consacré un chapitre entier à expliquer ces dangereuses règles de conversion implicite, puis ils ont ajouté de nombreuses règles assez complexes pour éviter les bogues causés par la conversion implicite. Cela a eu un certain impact sur tous les analyseurs statiques du marché.

Je recommanderais à n'importe quel programmeur C de lire ce chapitre MISRA-C, ou tout au moins de Google les deux règles de promotion que j'ai mentionnées et d'en lire autant que possible. Vous ne pouvez ignorer l'analyseur statique que lorsque vous savez tout ce qu'il faut savoir sur ces règles.

Maintenant, je ne pense pas vraiment que cette entreprise puisse être sauvée. Cependant, j'aimerais savoir s'il existe une meilleure façon, de préférence de travailler, d'utiliser les outils "pro" ou si je dois simplement éviter de les utiliser au cas où ce serait moi qui prendrais la décision à l'avenir.

Une solution qui ne suppose pas que tous les programmeurs sont des génies qui ne peuvent pas se tromper. Parce que bien, s'ils le sont, alors il n'est pas nécessaire d'utiliser les outils en premier lieu.

Il n'y a pas de solution simple. Le vrai problème n'est en fait pas l'outil, mais le langage C obscur. Cela peut sembler être un langage facile en bref, mais il existe de nombreux mécanismes illogiques et étranges entre les lignes. Et il y a aussi des centaines de cas de comportement non défini / non spécifié / impl. Spécifique dans la langue. La plupart d'entre eux, vous devez les apprendre et les éviter.

Vous devez donc soit devenir un programmeur C vétéran qui comprend tous ces avertissements obscurs, soit vous devez faire partie d'une équipe avec au moins une de ces personnes. Les entreprises qui n'embauchent qu'un groupe de programmeurs juniors sans vétéran dans l'équipe ne devraient pas utiliser ces outils, ni travailler avec le développement de logiciels à haute intégrité.

Il n'est pas clair si vous demandez comment résoudre le problème ou comment vous auriez pu l'éviter en premier lieu. Je suppose que ce dernier.

Il semble que vous vous soyez appuyé sur l'analyse statique comme principal moyen de détecter et d'éviter les bogues. Peut-être que vous auriez mieux fait de vous concentrer davantage sur les tests unitaires et les outils dynamiques ... tels que les vérificateurs de mémoire.

C'est une mauvaise idée de s'appuyer sur un outil qui génère beaucoup de faux positifs, surtout si vous ne pouvez pas supprimer ces faux positifs. Il encourage les programmeurs fatigués / surmenés (ou paresseux) à apporter des "correctifs" pour faire disparaître les avertissements. Si vous ne pouvez pas supprimer sélectivement les faux positifs (par exemple avec des commentaires) ou adapter l'ensemble de règles, alors vous avez besoin d'un meilleur outil. Ou du moins, vous ne devez l'utiliser qu'avec parcimonie.

Il semble que vous ayez un problème avec les personnes imprudentes et / ou faisant des erreurs à cause du surmenage. Peut-être auriez-vous dû consacrer plus de temps / d'efforts aux revues de code. Cela répond directement à votre observation selon laquelle les programmeurs ne sont pas des génies.

Enfin, il semble que vous souffriez peut-être de délais irréalistes, de pauvres ressources et / ou de changements de conditions. Il s'agit d'un problème de gestion, et doit être traité à ce niveau ... ou bien il existe un risque considérablement élevé d'échec du projet et des dommages à long terme à la productivité et au moral du personnel.

En plus de l'excellente réponse de user29079, je voudrais ajouter une autre déficience du langage C qui ajoute au problème. Je n'étais pas au courant de cette lacune jusqu'à ce que je passe à Java.

Le but d'un avertissement est d'attirer l'attention de l'auteur et des futurs lecteurs du code sur le fait qu'il se passe quelque chose de louche. Cela, en tant que concept, est parfaitement bien: plus vous avez activé d'avertissements, plus vous découvrez de choses louche.

Ce qui est vraiment faux , c'est l'idée que chaque petit truc de poisson doit être réparé à tout prix, en changeant le code . C'est ce qui a causé le problème que l'OP décrit: les tentatives bâclées de faire hâtivement disparaître les avertissements en modifiant le code qui fonctionne très bien.

En même temps, nous ne voulons pas que notre code génère des centaines d'avertissements à chaque fois que nous compilons, car très vite les avertissements perdent tout leur sens, et personne ne prête plus attention aux nouveaux avertissements.

Donc, cela semble être un cas d'objectifs contradictoires; une contradiction.

Une très bonne solution à ce dilemme apparemment impossible est de pouvoir supprimer sélectivement un certain avertissement, déclaration par déclaration, afin de pouvoir le supprimer précisément là où nous voulons indiquer que nous savons vraiment ce que nous faisons, sans avoir à modifier n'importe quel code.

Java a une bonne solution à cela, avec l' @SuppressWarnings( "" )annotation. Si vous effectuez, par exemple, une conversion dite non contrôlée en java, le compilateur émet un avertissement pour porter cela à votre attention, vous l'examinez, vous déterminez que c'est un de ces cas où vous savez ce que vous faites, vous faites donc précéder la déclaration incriminée d'une @SuppressWarnings( "unchecked" )annotation qui n'affecte que la déclaration qui la suit immédiatement, et vous poursuivez votre vie.

Ainsi, l'avertissement disparaît, le code reste inchangé et l'annotation de suppression se tient là, colorée en vert par la coloration syntaxique, pour documenter le fait qu'une conversion aléatoire est en cours, mais l'auteur promet que c'est bien. (*) Tout le monde est content.

En java, vous pouvez même préfixer des paramètres individuels aux fonctions avec @SuppressWarnings(), afin de désactiver un avertissement spécifique qui peut être émis sur ce paramètre spécifique uniquement.

Cependant, pour autant que je sache, C n'a jamais pris en charge aucun mécanisme standard pour supprimer sélectivement les avertissements sur les instructions, et certains compilateurs qui ont implémenté leurs propres mécanismes propriétaires l'ont fait de manière astucieuse, par exemple les #pragma warning (nnn:N)directives de Microsoft C. Le problème avec ces directives est que vous avez besoin de deux lignes de directives pour supprimer à la fois un avertissement pour une seule instruction et laisser cet avertissement activé pour les instructions qui suivent. Par conséquent, les programmeurs C sont très peu susceptibles de prendre l'habitude de supprimer un avertissement sur une base d'instructions individuelles, même lorsqu'ils savent que cet avertissement particulier sur cette instruction particulière est correct.

(*) quelqu'un pourrait affirmer que si vous l'autorisez, alors chaque programmeur de la maison supprimera les avertissements sans y penser; la réponse à cela est que vous pouvez faire tout ce que vous pouvez pour aider les programmeurs à mieux faire leur travail, mais il n'y a rien que vous puissiez faire s'ils décident activement de vous saboter.

Je dirais (sans en connaître les détails) que votre entreprise a commis des erreurs plus importantes et ce n'est que le symptôme: elle n'a pas correctement déterminé le domaine du logiciel produit, géré correctement l'équipe et défini des objectifs raisonnables.

Si le logiciel que votre équipe écrit est quelque chose de essentiel dont dépendent les vies humaines, les outils d'analyse statique sont importants et utiles. Étant donné que le «coût» d'un bogue, mesuré en argent (sans tenir compte du degré de cynisme) est élevé, des outils spéciaux sont nécessaires pour le travail. Il existe des directives pour le C et le C ++ pour utiliser en toute sécurité les fonctionnalités du langage (lisez ce qu'il faut éviter et jusqu'où aller pour l'éviter).
Cependant, dans une telle situation, avoir des employés qui travaillent le dimanche est une très mauvaise idée, d'ailleurs du contexte que vous avez fourni, j'extrapole que le travail bâclé n'est pas rare. Donc si c'est le cas, le problème est très trèsgrand, et votre direction essaie de le résoudre en utilisant de "meilleurs" outils. Malheureusement, ce n'est pas ainsi que les choses fonctionnent. Si je suis même proche de corriger, j'irais jusqu'à suggérer que vous commenciez à chercher un autre emploi. Un logiciel essentiel à la mission mal fait est quelque chose qui peut vous hanter et ruiner votre réputation professionnelle, sans parler des poursuites judiciaires.

Si, en revanche, votre équipe écrit quelque chose de beaucoup moins critique, les outils d'analyse statique avec un taux élevé de faux positifs ne feront que vous ralentir et, comme vous l'avez noté, les gens réagissent généralement à cela en trouver le maximum local dans leur efficacité, dans ce cas en se contentant de tricher autour des avertissements, au lieu d'essayer de fixer la raison sous-jacente. Donc, dans votre situation, l'utilisation de ces outils peut en fait détériorer la qualité du code source, et ils doivent généralement être évités.

Si vous avez besoin de gérer une équipe logicielle qui écrit du code C ou C ++, je dirais d'abord déterminer quels sont les principaux objectifs du projet. Si l'écriture de code sans bogue est de la plus haute importance (par exemple, la nouvelle application sociale super géniale pour iOS et Android ne correspond pas à cela), alors utilisez l'analyse statique, peut-être même jusqu'à la spécification formelle et la vérification formelle. Mais si c'est le cas, choisir de bons programmeurs et les faire travailler dans un environnement sain avec une charge de travail adéquate et une bonne semaine de 40 heures est beaucoup plus important.

Les gens ne peuvent pas travailler de manière responsable s'ils sont traités comme des esclaves (et quelqu'un qui occupe mes vacances est exactement cela) et les bons programmeurs refuseront tout simplement de le faire régulièrement, à moins qu'ils ne sachent pas mieux (et s'ils sont bons, les chances sont ils font).

Conclusion: définissez vos objectifs, puis déterminez les outils et le processus que vous utilisez, ne laissez pas les outils disponibles définir le processus (par exemple les objectifs) car une (mauvaise) gestion pourrait vouloir vous forcer.

Comme indiqué dans la réponse de k.steff, les outils d'analyse statique pour 'C' sont utiles si vous construisez un logiciel dans une situation critique (logiciel d'avion) ​​et ils doivent être utilisés dès le premier jour (pas après des mois de développement lorsqu'un bogue non reproductible se produit ).

L'utilisation de ces types d'outils tard dans le processus de développement est généralement le signe de mauvais choix de conception au début du processus.

Dans les logiciels non critiques, ces types d'outils sont utiles pour:
-rassurer la gestion, les faire se sentir utiles (nous avons fait quelque chose, nous avons dépensé beaucoup d'argent pour réparer le logiciel). Cela leur donne des actions faciles à réaliser dans leurs reportages PowerPoint).
-Gardez les développeurs «toxiques» occupés. Laissez-les configurer l'outil et analyser les résultats de l'outil, afin que vous puissiez avoir le temps de corriger leurs vilains bugs.
-appliquer les règles de codage. Dans ce cas, il doit être utilisé dès le premier jour. Mais un bon outil de révision de code peut être un meilleur choix.

Donc, à mon avis, vous devez éviter ces types d'outils coûteux et longs ou les utiliser pour occuper les personnes «toxiques».

Je travaille dans une entreprise qui obtiendrait 11 sur Joel Test - au moins sur papier.

La validation par le test Joel n'est pas une mesure de bonnes pratiques; L'invalidation par le test Joel est cependant une mesure des mauvaises pratiques / des pratiques manquantes. En d'autres termes, cela peut être considéré comme nécessaire, mais pas suffisant.

Maintenant, la plupart de mes pairs sont heureux s'ils peuvent rentrer chez eux à 18 heures - dimanche.

Il semble que vous ayez un problème de gestion. Les heures supplémentaires systématiques ne sont pas une solution pour faire avancer les choses; au contraire, c'est une solution pour donner l' impression que les choses fonctionnent et accumuler de la dette technique.

Maintenant, je ne pense pas vraiment que cette entreprise puisse être sauvée. Cependant, j'aimerais savoir s'il existe une meilleure façon, de préférence de travailler, d'utiliser les outils "pro" ou si je dois simplement éviter de les utiliser au cas où ce serait moi qui prendrais la décision à l'avenir.

Oui, il existe un moyen d'utiliser l'analyse de code statique de manière saine.

Ils peuvent, et fournissent généralement beaucoup de valeur. Vous devez juste vous rappeler que, (comme les avertissements du compilateur), un outil d'analyse statique peut (tout au plus) fournir des indices de quelque chose qui ne va pas - pas des rapports de bogues, et aucune certitude.

Il semble que vos décideurs confondent les indicateurs d'analyse statique avec les défauts d'application.

Les moulages implicites sont également sur liste noire sur leur livre de styles.

Cela ressemble à un problème de compétence de gestion, pas à un problème d'analyse statique.

Le résultat est:

Les gens ajoutent des transtypages de type à chaque valeur r et à chaque argument cachant de véritables asymétries de type problématique dans le processus.

Les gens introduisent un bogue ou utilisent une fonction de langage problématique différente (strlen au lieu de sizeof, strncpy au lieu de strcpy, etc.)

Les avertissements sont réduits au silence.

Les rapports de bogues commencent à rouler.

Ce sont toutes des façons de donner une bonne apparence aux rapports périodiques, pas de résoudre les problèmes dans le code (il semble que vous ayez à nouveau un problème de compétence en gestion).