Open Source : la communauté, un plus pour la fiabilité du code

L'Open Source de mieux en mieux sécurisé et de plus en plus réactif pour corriger ses bogues. C'est un des messages qu'il faut retenir de la lecture du Scan Report 2008 de Coverity. Soutenu par le ministère de l'Intérieur américain (Department of Homeland Security), le service mis en place par Coverity a, pendant deux ans, passé au crible quelque 265 applications Open Source et la réactivité de leur communauté. Plus de 55 millions de lignes de code ont ainsi été analysées par l'outil Scan Coverity. Des projets, aussi populaires du mouvement que Linux, Samba, Apache, Firefox, mais également PHP et Ruby, ont subi les assauts de la moulinette analytique.

Attention aux faux positifs

L'un des points forts de ce rapport : il mesure la capacité des projets Open Source à combler les failles découvertes par l'outil de Coverity. En fonction de leur réactivité et de leur capacité à trouver des parades, les projets gravissent les échelons (de Rung 0 à Rung 2). Le passage au plus haut degré donne alors accès à des analyses complémentaires.

C'est donc vers les communautés, bases du mouvement, que se tournent tous les regards. Et vers son modèle de développement. « L'analyse de code est un bon moyen de détecter certaines catégories de bugs, mais l'exercice est rendu difficile par sa nature statique, explique Julien Blache, développeur officiel pour Debian. Le nombre de faux positifs peut être non négligeable si l'outil n'est pas suffisamment mature, et il est indispensable dans tous les cas de vérifier humainement (au moins un minimum) les résultats avant de les faire parvenir aux projets concernés », souligne-t-il . Et d'ajouter : « Dans le cas contraire, on risque au mieux de faire perdre du temps aux développeurs, au pire de leur faire introduire de nouveaux bugs. »

8 500 erreurs nettoyées

Les résultats 2008 sont plutôt encourageants pour l'Open Source. Sur les 250 projets partant du premier échelon (Rung 0), Coverity a noté une progression de 16% dans l'élimination d'anomalies de code au fil des deux années. Preuve d'une amélioration concrète dans la qualité et la sécurité des applications Open Source, explique le rapport. 8 500 erreurs ont alors été « nettoyées ».
Parmi les autres trouvailles, les chercheurs du Scan Coverity ont noté la prédominance de certaines erreurs : la plus courante en 2008 étant le déréférencement de pointeur NULL.
« Sur la base des commentaires formulés par les lecteurs des premières versions du rapport, la version finale contient des révélations assez surprenantes sur les liens entre densité d'erreurs et complexité du code, et jette de solides bases pour les travaux de recherche futurs sur la nature des logiciels », explique également David Maxwell, analyste stratégique Open Source chez Coverity. Comprendre : ce n'est pas parce que le code source est long et ses fonctions nombreuses que le code est davantage exposé à des erreurs.

Du temps gagné pour le débug

Nuançons toutefois ces chiffres. Si 265 projets ont gravi les échelons, cela représente un goutte d'eau dans l'océan. Pendant ces deux années, 14 238 projets ont été analysés au total. Soit 10 milliards de lignes de code scrutées. Autant de logiciels dont le mécanisme reste soit rouillé, soit sujet à des anomalies que certains ne parviennent pas à résoudre.
Au-delà, cette méthode est un baromètre fiable tant pour les développeurs que pour les entreprises. Chez les premiers, l'avantage est évident. « Un tel outil permet un gain de temps considérable sur la détection de certains types de bugs, ce qui est autant de temps économisé sur le debug à posteriori. Au final, cela touche tout le monde, autant les développeurs que les utilisateurs », commente Julien Blache.  Pour les entreprises, la cartographie que livre Coverity permet d'apporter un reférentiel de logiciel Open Source, pour en fin de compte, aider à l'adoption du modèle dans les SI.