IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)

Vous êtes nouveau sur Developpez.com ? Créez votre compte ou connectez-vous afin de pouvoir participer !

Vous devez avoir un compte Developpez.com et être connecté pour pouvoir participer aux discussions.

Vous n'avez pas encore de compte Developpez.com ? Créez-en un en quelques instants, c'est entièrement gratuit !

Si vous disposez déjà d'un compte et qu'il est bien activé, connectez-vous à l'aide du formulaire ci-dessous.

Identifiez-vous
Identifiant
Mot de passe
Mot de passe oublié ?
Créer un compte

L'inscription est gratuite et ne vous prendra que quelques instants !

Je m'inscris !

Une enquête de Rollbar révèle que la correction des bugs est le principal problème des développeurs
L'investigation montre également que la surveillance traditionnelle des erreurs ne fonctionne pas

Le , par Nancy Rey

259PARTAGES

5  0 
Une enquête auprès de 950 développeurs publiée hier révèle que plus d'un tiers (38 %) des développeurs passent jusqu'à un quart de leur temps à corriger des bogues logiciels et un peu plus d'un quart (26 %) jusqu'à la moitié de leur temps à corriger des bogues. Réalisé en décembre dernier par le cabinet d'études de marché Propeller Insights pour le compte de Rollbar (un fournisseur d'outils d'intelligence artificielle pour détecter les erreurs logicielles), le rapport note également que 88 % des développeurs trouvent que les outils traditionnels de surveillance des erreurs ne répondent pas aux attentes.

« Cette recherche met en évidence les défis extrêmes auxquels les développeurs et leurs entreprises sont confrontés lorsqu'ils corrigent des bogues et des erreurs de logiciels. La surveillance traditionnelle des erreurs ne suffit tout simplement pas dans un monde où le logiciel est devenu un aspect important du fonctionnement de la société », a déclaré Francesco Crippa, vice-président de l'ingénierie chez Rollbar.


Selon les résultats de l’enquête, les développeurs de la génération Z (les personnes nées entre 1997 et 2010) sont le groupe d'âge le plus susceptible de se plaindre de l'approche traditionnelle de la surveillance des erreurs. 94 % des développeurs de la cohorte des 18 à 24 ans ont admis que la surveillance traditionnelle des erreurs ne répondait pas de manière adéquate à toutes leurs exigences. Et ils ne sont pas seuls. Plus des trois quarts (79 %) des développeurs du groupe Boomer sont d'accord. Propeller Insights définit les Boomers comme des personnes âgées de 65 ans ou plus.

La majorité des répondants à l'enquête ont déclaré que la surveillance traditionnelle des erreurs est loin d'être idéale, car :
  • elle les oblige à répondre manuellement aux erreurs (39 %) ;
  • il leur faut trop de temps pour trouver tous les détails dont ils ont besoin pour corriger les bugs et les erreurs (36 %) ;
  • ils se concentrent sur la stabilité du système et pas assez sur le code de santé (31 %) ;
  • elle rend difficile la détection des erreurs (29 %) ;
  • son approche de l'agrégation des erreurs est soit trop large, soit trop étroite (23 %).


Les processus manuels rendent la correction des bugs longue et fastidieuse et le travail des développeurs désagréable

Les logiciels permettent l'innovation, la révolution industrielle, la transformation numérique et des résultats positifs pour les entreprises et la société. Mais ils peuvent aussi laisser les développeurs dans l'embarras.

Plus d'un tiers (38 %) des développeurs ont déclaré qu'ils consacraient jusqu'à un quart de leur temps à corriger les bogues des logiciels. Un peu plus d'un quart (26 %) ont déclaré qu'ils passaient jusqu'à la moitié de leur temps à corriger des bogues. 8 % des personnes interrogées ont déclaré qu'elles devaient consacrer jusqu'à trois quarts de leur temps à la correction de bogues. Les développeurs occidentaux ont tendance à passer le plus de temps à corriger les bogues. Un dixième du groupe dans l'ouest des États-Unis a déclaré que jusqu'à 75 % de leur temps est consacré à de telles activités.

Il s'agit d'une lutte majeure pour les développeurs, comme le montrent les statistiques de l’enquête : 44 % des développeurs ont déclaré que leur plus grand malheur était de corriger les bogues et les erreurs des logiciels. Les développeurs milléniaux (personnes nées entre le début des années 1980 et la fin des années 1990) et ceux de la Generation Z ont indiqué qu'ils trouvent ces efforts particulièrement douloureux. Près de la moitié (48,3 %) des développeurs milléniaux ont déclaré que la correction des bogues et des erreurs est leur plus grand point de difficulté. Presque autant de répondants de la Génération Z (45,8 %) ont déclaré qu'ils considèrent cela comme l'aspect le plus douloureux de leur travail.

En fait, près des deux tiers de tous les développeurs ont déclaré qu'ils préféreraient faire une activité désagréable plutôt que de corriger des erreurs. Plus d'un quart (26 %) ont déclaré qu'ils préféreraient payer des factures. Plus d'un cinquième (21 %) ont déclaré qu'ils préféreraient aller chez le dentiste. Et 20 % préféreraient passer du temps avec leur belle-famille.

Les développeurs passent trop de temps à réparer le code et pas assez à l'écrire

Plus problématique encore est le fait que les développeurs ont déclaré que la correction du code prenait du temps sur des travaux plus importants. Près d'un tiers (32 %) des développeurs ont déclaré qu'ils passaient jusqu'à 10 heures par semaine à corriger des bugs au lieu d'écrire du code. 16 % ont déclaré qu'ils passaient jusqu'à 15 heures par semaine et 6 % ont déclaré qu'ils devaient consacrer jusqu'à 20 heures par semaine à corriger des bogues au lieu d'écrire du code.

Plus de la moitié des développeurs (55 %) ont déclaré que s'ils ne passaient pas autant de temps à corriger les bogues, ils auraient le temps de créer de nouvelles fonctionnalités. Quarante-deux pour cent de l'ensemble du groupe interrogé ont déclaré qu'ils feraient leur travail si ce n'était du temps passé à corriger des bogues.

Répondre manuellement aux erreurs crée des problèmes personnels et professionnels aux développeurs

L'enquête Rollbar suggère que le fait d'avoir à répondre manuellement à des erreurs a des répercussions considérables sur les performances professionnelles, le moral et même la qualité de vie globale des développeurs. Près d'un tiers des personnes interrogées (31 %) ont déclaré que le fait de répondre manuellement aux erreurs les frustrait. Plus d'un cinquième des développeurs (22 %) ont déclaré se sentir dépassés lorsqu'ils utilisent des processus manuels pour traiter les erreurs dans les logiciels. Presque autant (17 %) ont déclaré que cela les conduisait à l'épuisement professionnel.

Certains développeurs ont des réactions encore plus fortes. Plus d'un dixième (12 %) disent que cela suscite des sentiments de ressentiment et 7 % disent que cela leur donne envie de quitter leur emploi. Le désir de démissionner en raison de tels processus est plus prononcé chez les développeurs de l'Ouest ; 9 % de ce groupe ont déclaré que le fait de répondre manuellement aux erreurs leur donne envie de trouver un emploi ailleurs.

Les entreprises souffrent aussi parce que les plaintes des utilisateurs et les erreurs des logiciels sont mauvaises pour la marque

Malgré tout le temps et les efforts que les développeurs consacrent à la correction du code, les erreurs et les bogues ne sont toujours pas détectés. Malheureusement, les utilisateurs trouvent souvent ces problèmes avant les développeurs et leurs employeurs.

Près des deux tiers des développeurs (62 %) ont déclaré avoir découvert des erreurs grâce aux utilisateurs qui les ont signalées par l'intermédiaire de l'application. Pire encore, les utilisateurs de logiciels peuvent faire part de leurs plaintes dans des forums publics. Un quart (25 %) des développeurs ont déclaré avoir entendu parler d'erreurs par des utilisateurs partageant ces problèmes sur les médias sociaux. Une part encore plus importante des développeurs plus âgés a indiqué avoir vécu cette expérience. Plus de 70 % des développeurs âgés de 45 à 64 ans et près de 83 % des développeurs de plus de 65 ans ont déclaré qu'ils avaient été informés d'erreurs par des utilisateurs se plaignant sur les médias sociaux.

D'autres fois, les développeurs ont déclaré qu'ils avaient appris l'existence de bogues et d'erreurs dans les médias ou même directement par le PDG de leur entreprise. 17 % des développeurs ont déclaré que la couverture médiatique les avait renseignés sur les erreurs de leur logiciel. Plus d'un cinquième (21 %) des développeurs interrogés dans le cadre de l'enquête Rollbar ont déclaré avoir entendu parler d'erreurs par leur PDG.

Près de neuf développeurs sur dix (89 %) sont d'accord pour dire que les erreurs non détectées peuvent avoir des conséquences importantes sur l'entreprise. Plus d'un quart (26 %) des développeurs ont déclaré que leurs employeurs ont perdu un nombre important d'utilisateurs en raison d'erreurs dans les logiciels. La même proportion (26 %) déclare que les erreurs de logiciels nuisent à la réputation de leur entreprise et à sa capacité à attirer des investissements et près d'un cinquième (18 %) déclare que les problèmes de logiciels non détectés irritent les investisseurs existants de leur entreprise.

« Les logiciels sont maintenant au cœur de chaque entreprise, c'est pourquoi eux et leurs investisseurs comprennent l'intérêt d'offrir une expérience utilisateur exceptionnelle. Mais le logiciel est fait de code et le code n'est pas parfait. Les bugs et les erreurs sont inévitables. Mais avec l'amélioration continue du code, les développeurs responsables des applications critiques peuvent non seulement identifier les bogues et leur cause première, plus rapidement, ils peuvent automatiser les étapes pour y remédier. Ils peuvent ainsi consacrer moins de temps à la surveillance, à l'étude et au débogage du code et plus de temps à l'innovation pour obtenir des résultats commerciaux », a déclaré Brian Rue, PDG et cofondateur de Rollbar.

Source : Rollbar

Et vous ?

Que pensez-vous des résultats de cette enquête ? Les trouvez-vous pertinents ?

Voir aussi :

Code Defect AI, un outil IA pour aider les développeurs à repérer les bogues pendant le codage et non à la fin, disponible en open source sous licence Apache v2.0

Google et Intel mettent en garde contre un bogue de sécurité sous Linux qui permet d'exécuter un code malveillant via Bluetooth, Intel recommande une mise à jour vers la version 5.9 du noyau

Le « ;bug de l’an 2000 ;» se reproduira en 2038 dans le monde Linux, mais c’est maintenant qu’il faut s’inquiéter selon Jon Corbet

Une erreur dans cette actualité ? Signalez-le nous !