Comment nous mesurons la Qualité des logiciels
Avant de pouvoir livrer un produit logiciel, nous devons mesurer sa qualité pour nous assurer qu’il est aussi exempt de bogues que possible. Cependant, pour ce faire, nous devons d’abord savoir sur quelles mesures de qualité logicielle nous mesurons.
Quelles sont les Mesures pour Mesurer la Qualité des logiciels ?
Les mesures pour mesurer la qualité des logiciels peuvent être extrêmement techniques, mais peuvent être résumées dans les quatre catégories essentielles suivantes:
- Qualité du code
- Performance
- Sécurité
- Convivialité
Qualité du code
Un code sans bogue et sémantiquement correct est très important pour les logiciels premium. Les normes de qualité du code peuvent être divisées en mesures quantitatives et qualitatives. Les mesures de qualité quantitatives mesurent la taille ou la complexité du logiciel, le nombre de lignes et de fonctions qu’il contient, le nombre de bogues par 1 000 lignes de code, etc. Les indicateurs qualitatifs de la qualité du code mesurent des fonctionnalités telles que la maintenabilité, la lisibilité, la clarté, l’efficacité et la documentation. Ces mesures mesurent à quel point le code est facile à lire, à comprendre et s’il est écrit selon les normes de codage.
Performance
Chaque logiciel est conçu pour un but. Les indicateurs de performance mesurent si le produit remplit son objectif et s’il fonctionne comme prévu. Il fait également référence à la façon dont l’application utilise les ressources, à son évolutivité, à la satisfaction des clients et aux temps de réponse.
Sécurité
Les mesures de sécurité logicielles mesurent la sécurité inhérente à un programme logiciel et garantissent qu’il n’y a pas de modifications non autorisées dans le produit lorsqu’il est remis au client.
Utilisabilité
Étant donné que tous les produits logiciels sont conçus pour un utilisateur final, une mesure de qualité importante est de savoir si le programme est praticable et convivial. Nous veillons également à ce que le client soit satisfait des fonctionnalités et des performances.
Quand Mesurons-Nous La Qualité Des Logiciels ?
Notre équipe de développement de logiciels et notre équipe d’assurance qualité (QA) travaillent ensemble pour garantir que la qualité du logiciel est du plus haut niveau. L’équipe d’assurance qualité effectue des tests de produits, une fois développés. Cependant, l’équipe de développement maintient, mesure et améliore constamment la qualité du logiciel pendant la construction. Cependant, bien que nous maintenions la qualité des logiciels à chaque étape du développement, nous pouvons les tester à différents moments du développement, en fonction de la méthodologie de développement utilisée. Nous utilisons deux méthodologies lors du développement d’applications logicielles – Waterfall et Agile. Étant donné que les deux méthodologies livrent le produit de différentes manières, elles sont également testées différemment.
Mesure de la qualité du logiciel: Méthodologie en cascade
La méthodologie en cascade consiste à planifier, exécuter, tester et livrer en phases distinctes. Chaque phase est terminée avant le début de la suivante. En conséquence, avec un produit développé en utilisant cette méthodologie, nous devons maintenir la qualité du produit à chaque étape – exigences, conception, mise en œuvre, vérification (ou test) et maintenance. Étant donné que les tests sont effectués à la fin de la construction, cela prend moins de temps et ne nécessite pas beaucoup de tests de régression.
Mesure de la qualité des logiciels : Agile
Les méthodologies Agiles sont plus réactives et flexibles, où le développement est décomposé en phases, ou sprints. L’objectif est qu’à la fin de chaque sprint, qui peut durer de deux à six semaines, nous livrons un produit minimum viable de haute qualité, entièrement fonctionnel et testé. Cela signifie que nous devons nous assurer de maintenir la qualité du logiciel produit à chaque étape, dans chaque sprint. Les produits développés en utilisant les méthodologies Agiles sont testés plus souvent. Cependant, cela signifie également qu’ils ont besoin de tests de régression constants pour s’assurer qu’une mise à jour n’a pas cassé les fonctionnalités qui ont été testées et passées dans les versions précédentes.
Comment les Développeurs Maintiennent-ils la Qualité du Code Logiciel ?
Un bon développeur est celui qui peut fournir un code logiciel de haute qualité avec un minimum de bogues. Nous disons « minimal » car, pendant le développement, certains bugs sont inévitables et ce qui compte, c’est comment nous les corrigeons ou les contrôlons. C’est pourquoi les développeurs mesurent la qualité de leur code au fur et à mesure de leur développement, car cela signifie qu’ils peuvent identifier et résoudre les problèmes pendant la construction. Ils mesurent leur code par rapport aux normes de codage, aux revues de code, aux analyseurs de code et au code hérité du réfracteur.
À ce stade, la qualité du logiciel est testée manuellement avec des tests unitaires courts. Un test unitaire est la première étape de la mesure de la qualité du logiciel, où la plus petite partie testable du logiciel – un module ou un composant du programme ou même une seule fonction dans le code – est vérifiée.
Par exemple, il peut y avoir un certain nombre de champs de données à remplir dans le cadre d’un logiciel plus grand. Un test unitaire peut simplement tester le premier champ et non les autres, ou même toute autre partie du logiciel.
Les développeurs créent une bibliothèque partagée de centaines de tests de ce type, avec des fonctionnalités répétables intégrées dans le logiciel, de sorte que ces tests peuvent être utilisés encore et encore, à travers des projets pour détecter efficacement les erreurs dans le code logiciel au stade du développement. Ils effectuent également des tests automatisés à l’aide d’un analyseur de code, SonarQube, qui vérifie les logiciels pour:
- Clarté
- Maintenabilité
- Documentation
- Extensibilité
- Efficacité
- Bien testé
- Codage sécurisé
- Refactorisation du code
- Extensibilité
Ça nous aide:
- Effectuer des révisions du code
- Maintenir les normes de codage
- Identifier les bogues et le nombre de bogues potentiels dans le logiciel
Nous l’utilisons également pour évaluer:
- La complexité structurelle du programme (nombre de lignes de code)
- Toutes les vulnérabilités trouvées dans les dépôts
- Odeurs de code (code déroutant ou difficile à maintenir)
- Couverture de code (mesure du code couvert par des tests unitaires)
- Duplication de code (quantité de code répétée)
Comment l’Équipe D’Assurance Qualité Mesure-t-Elle La Qualité Des Logiciels ?
Les testeurs d’assurance qualité examinent toutes les mesures de la qualité des logiciels grâce à des tests manuels et automatisés (utilisant du sélénium), y compris la validité et la norme du code produit. Les métriques de test manuelles peuvent être divisées en deux classes : les métriques de base et les métriques calculées. Les métriques de base sont constituées des données brutes non analysées collectées, tandis que les métriques calculées sont dérivées des informations collectées dans les métriques de base.
Métriques de test manuel
Certaines des métriques de test manuel importantes que nous considérons pour la qualité du logiciel sont:
- Métriques de productivité d’exécution de cas de test
- Métriques de productivité de préparation de cas de test
- Durée du test
- Couverture des tests unitaires (la quantité de code logiciel couverte par les tests unitaires)
- Pourcentage de réussite/échec des tests, etc.
Métriques de test d’automatisation
Les tests d’automatisation peuvent aider à réduire le temps manuel consacré aux tests de qualité des logiciels. Voici quelques-unes des mesures importantes pour les tests d’automatisation que nous considérons:
- Durée totale du test
- Couverture du test unitaire
- Couverture du chemin (combien de chemins linéairement indépendants du programme couverts par le test)
- Couverture des exigences
- Pourcentage de réussite / échec des tests
- Nombre de défauts
- Pourcentage de couverture de test automatisée (par rapport à la couverture de test totale qui comprend les tests manuels)
- Exécution des tests (total des tests exécutés pendant la génération)
- Résultats utiles par rapport aux résultats non pertinents
- Défauts de production
- Pourcentage de versions brisées, etc.
Autres types de tests pour mesurer la Qualité des logiciels
Nous utilisons également différents types de tests pour mesurer la qualité des logiciels. Ce sont:
- Test fonctionnel
- Test de Rupture
- Test de Performance de charge
- Test de Régression
- Test de sécurité
- Test de pénétration
- Test d’acceptation par l’utilisateur