Avertissements du compilateur

De nombreux compilateurs ont des messages d'avertissement pour avertir les programmeurs des erreurs d'exécution, de logique et de performances potentielles, la plupart du temps, vous les corrigez rapidement, mais qu'en est-il des avertissements non corrigés?

Comment gérez-vous les avertissements non corrigés? Réécrivez-vous une partie du code, ou réécrivez-vous de la "manière longue et sans hack" ou désactivez-vous tous les avertissements? Quelle devrait être la meilleure pratique?

Que faire si vous modifiez le code de quelqu'un d'autre et que son code comporte des avertissements?

Voici un bon exemple: jQuery a beaucoup d'avertissements JavaScript détectés par un navigateur de classe Mozilla, pourquoi les développeurs jQ ne les corrigent pas? Si vous contribuez à jQuery, allez-vous les corriger?

Certains avertissements sont généralement sûrs d'ignorer, mais si vous le faites, ils se multiplieront avec le temps jusqu'à ce que ce jour arrive où il y en a tellement que vous manquez le seul avertissement qui compte vraiment car il est caché dans le bruit.

Corrigez les avertissements immédiatement (ce qui peut inclure la désactivation de règles individuelles si vous pensez que cela n'est jamais pertinent pour votre contexte).

Mon opinion est que vous devez être strict avec vous-même. Le compilateur a été écrit par un total d'experts dans la langue. S'ils signalent que quelque chose est un peu incertain (pensez à l'odeur du code), le code doit être examiné.

Il est tout à fait possible d'écrire du code qui se compile sans erreurs et sans avertissements.

Lorsque j'écrivais en C et C ++, j'activais les paramètres les plus stricts que je pouvais parce que je voulais savoir quand quelque chose n'avait pas de sens pour le compilateur. Quand j'aurais fini de lancer et de vérifier les valeurs de retour, je serais heureux parce que le code était aussi correct que possible.

Je recevais de temps en temps du code de quelqu'un d'autre qui émettait des avertissements. La vérification de la source a montré qu'ils ignoraient les choses qui étaient de bonnes pratiques de programmation en C, rendant leur code fragile.

Donc, je pense qu'il y a de bonnes raisons de permettre la rigueur et de prendre le temps de réparer les choses. Faire autrement est bâclé. Si j'avais un collègue qui désactivait les avertissements, je passerais un peu de temps avec eux ET le directeur expliquerait pourquoi c'est vraiment une mauvaise chose.

Je fixerais n'importe quel avertissement. Si vous les ignorez et les laissez s'accumuler, vous pourriez en fait manquer quelque chose d'important.

En règle générale, vous devez vous efforcer de rendre le compilateur silencieux, afin que les nouveaux avertissements s'affichent davantage. Ces avertissements peuvent indiquer des bogues subtils et doivent être traités en conséquence.

En ce qui concerne la fixation du code d'autres personnes, cela dépend fortement à la fois de votre culture de travail et de l'état actuel du code. Vous ne pouvez pas simplement modifier le code s'il déclenche un cycle de test complet, comme il le ferait pour le code tard dans la phase de test ou en production.

Demandez à votre patron et agissez en conséquence.

Chaque fois que vous voyez un avertissement du compilateur, vous devez vous arrêter et vous demander s'il s'agit vraiment d'un problème en attente de vous exploser au visage sur le site du client ou de quelque chose que vous pouvez ignorer. Pire, les choses que vous pouvez ignorer AUJOURD'HUI peuvent être des choses qui exploseront sur le site du client dans quelques années, après un changement de code apparemment sans rapport avec Somewhere Else.

Corrigez les avertissements. Période. C'est cela ou documentez chacune d'entre elles, avec autant de pages d'explications que nécessaire pour prouver que ce n'est pas un risque, accompagné d'une commande client signée sur votre petite amie préférée (ou cachette porno) s'il s'avère que cela ÉTAIT un risque.

En règle générale, vous souhaitez que votre version soit sans avertissement. Les avertissements sont là pour une raison, et souvent ils indiquent des problèmes très réels. Si vous prenez l'habitude d'ignorer les avertissements du compilateur, votre build en finira par en avoir une tonne, et vous manquerez le seul avertissement causé par un problème catastrophique qui coûtera cher à votre entreprise. D'un autre côté, si votre programme compile normalement sans avertissements, alors chaque nouvel avertissement est immédiatement remarqué et peut être traité rapidement.

Cela dit, les compilateurs peuvent parfois avoir des avertissements qui n'ont pas de sens et qui ne peuvent pas être facilement corrigés. Je fais face à cette situation tous les jours au travail avec TI CodeComposer, qui est un environnement de développement pour les DSP TI. J'ai du code C ++ qui se compile sans avertissement sous Visual Studio, mais qui entraîne des avertissements étranges dans CodeComposer, simplement parce que la prise en charge de TI pour le C ++ standard pourrait être meilleure. Heureusement, CodeComposer vous permet de désactiver des avertissements spécifiques individuellement, ce que nous devons faire lorsqu'il n'y a aucun moyen de corriger le code qui produit l'avertissement.

Dans mon cas, les avertissements proviennent de l'outil PyLint et je peux désactiver un avertissement sur une ligne particulière en ajoutant du texte spécial dans les commentaires.

Dans la plupart des cas, je ne fais pas ça. Dans la plupart des cas, je change le code pour suivre ce que PyLint suggère car PyLint est généralement correct. Cependant, en n'aime pas les constructions qui sont généralement une mauvaise idée, mais qui ont du sens dans un contexte particulier. Par exemple, il se plaint si j'attrape toutes les exceptions possibles. Habituellement, c'est correct, ce serait une mauvaise idée. Cependant, dans certains cas, je veux attraper toutes les exceptions telles que m'envoyer un rapport d'erreur avec les détails.

Donc: dans presque tous les cas, débarrassez-vous des hacks. Lorsque le hack est vraiment justifié, ajoutez un commentaire indiquant à PyLint que tout va bien.

Certains des avantages de la rigueur n'étaient pas clairement énoncés dans les autres réponses:

1. Lorsque tous les avertissements facilement réparables ont été corrigés, les avertissements significatifs / pertinents restants sont plus susceptibles de s'afficher.
2. Si les avertissements pertinents sont trouvés et traités à temps (avant la publication), les bogues peuvent être évités, conduisant ainsi à une meilleure satisfaction de l'utilisateur final
3. La résolution de l'avertissement conduit généralement à un code plus simple et plus facile à gérer (par exemple, l'élimination des conditions qui sont toujours vraies)
4. Lorsque le nombre d'avertissements est plus proche de 0, il est facile de s'entendre sur la politique de zéro avertissement dans l'équipe, qui est très facile à automatiser dans le système CI.
5. Lors de la résolution des avertissements du compilateur, la compréhension du code du programme s'approfondit, ce qui peut conduire à des informations utiles sur la mise en œuvre (par exemple, découvrir d'autres bogues ou obtenir des idées sur la façon de développer davantage le code)
6. La construction s'accélère, la productivité quotidienne augmente: l'IDE / le compilateur a moins de problèmes à gérer et à rendre compte, donc la compilation est plus rapide (cela n'est pertinent que dans le contexte de milliers d'avertissements).

Il existe des différences spécifiques à la langue sur certains types d'avertissements. Je pense qu'il est important de réfléchir et de discuter sur le sujet, puis de désactiver certains avertissements individuels s'ils se sentent totalement inutiles afin que la rigueur puisse être atteinte. Cela a été accompli dans plusieurs équipes au cours de ma carrière. Plus sur mes expériences sur le sujet

Les avertissements et les erreurs sont des messages que le compilateur utilise pour dire au programmeur "quelque chose que vous avez écrit n'a pas de sens" - la différence entre eux est qu'avec un avertissement, le compilateur est prêt à faire une supposition quant aux intentions du programmeur, alors que avec une erreur, le compilateur ne peut même pas faire de supposition.

Les erreurs du compilateur seront corrigées (je ne vais pas dire corrigées ), mais trop souvent, les programmeurs (même expérimentés) ignoreront les avertissements. Le problème de l'ignorance des avertissements est que parfois le compilateur se trompe et si vous avez plus de 1000 messages d'avertissement, il est facile de manquer un message d'avertissement qui indique que le compilateur se trompe.

D'un point de vue sociologique, les programmes qui contiennent de nombreux messages d'avertissement sont des fenêtres brisées .