Wie wir die Softwarequalität messen
Bevor wir ein Softwareprodukt liefern können, müssen wir seine Qualität messen, um sicherzustellen, dass es so fehlerfrei wie möglich ist. Dazu müssen wir jedoch zunächst wissen, an welchen Softwarequalitätsmetriken wir messen.
Was sind die Metriken zur Messung der Softwarequalität?
Die Metriken zur Messung der Softwarequalität können äußerst technisch sein, lassen sich jedoch in die folgenden vier wesentlichen Kategorien einteilen:
- Codequalität
- Leistung
- Sicherheit
- Benutzerfreundlichkeit
Codequalität
Fehlerfreier und semantisch korrekter Code ist für Premium-Software sehr wichtig. Codequalitätsstandards können in quantitative und qualitative Metriken unterteilt werden. Quantitative Qualitätsmetriken messen, wie groß oder komplex das Softwareprogramm ist, wie viele Zeilen und Funktionen es enthält, wie viele Fehler es pro 1.000 Codezeilen gibt und vieles mehr. Qualitative Codequalitätsmetriken messen Funktionen wie Wartbarkeit, Lesbarkeit, Klarheit, Effizienz und Dokumentation. Diese Metriken messen, wie einfach der Code zu lesen und zu verstehen ist und ob er gemäß Codierungsstandards geschrieben wurde.
Leistung
Jedes Softwareprogramm wurde für einen bestimmten Zweck entwickelt. Leistungsmetriken messen, ob das Produkt seinen Zweck erfüllt und ob es so funktioniert, wie es soll. Es bezieht sich auch auf die Ressourcennutzung der Anwendung, ihre Skalierbarkeit, Kundenzufriedenheit und Antwortzeiten.
Sicherheit
Software-Sicherheitsmetriken messen die inhärente Sicherheit eines Softwareprogramms und stellen sicher, dass bei der Übergabe an den Kunden keine unbefugten Änderungen am Produkt vorgenommen werden.
Benutzerfreundlichkeit
Da alle Softwareprodukte für einen Endbenutzer entwickelt wurden, ist eine wichtige Qualitätsmetrik, ob das Programm praktikabel und benutzerfreundlich ist. Wir stellen auch sicher, dass der Kunde mit den Funktionen und der Leistung zufrieden ist.
Wann messen wir Softwarequalität?
Unser Softwareentwicklungsteam und das Qualitätssicherungsteam (QA) arbeiten zusammen, um sicherzustellen, dass die Softwarequalität dem höchsten Standard entspricht. Das QA-Team führt Produkttests durch, sobald sie entwickelt wurden. Das Entwicklungsteam pflegt, misst und verbessert jedoch auch die Softwarequalität während des Builds ständig. Während wir jedoch die Softwarequalität in jeder Entwicklungsphase aufrechterhalten, können wir sie an verschiedenen Stellen in der Entwicklung testen, basierend auf der verwendeten Entwicklungsmethodik. Bei der Entwicklung von Softwareanwendungen verwenden wir zwei Methoden – Wasserfall und Agil. Da die beiden Methoden das Produkt auf unterschiedliche Weise liefern, werden sie auch unterschiedlich getestet.
Messung der Softwarequalität: Wasserfallmethodik
Bei der Wasserfallmethodik planen, führen, testen und liefern wir in verschiedenen Phasen. Jede Phase ist abgeschlossen, bevor die nächste beginnt. Daher müssen wir bei einem Produkt, das mit dieser Methodik entwickelt wurde, die Qualität des Produkts in jeder Phase aufrechterhalten – Anforderungen, Design, Implementierung, Verifizierung (oder Test) und Wartung. Da die Tests am Ende des Builds durchgeführt werden, dauert es weniger Zeit und erfordert nicht viel Regressionstests.
Messung der Softwarequalität: Agil
Die agilen Methoden sind reaktionsschneller und flexibler, wobei die Entwicklung in Phasen oder Sprints unterteilt ist. Das Ziel ist, dass wir am Ende jedes Sprints, der zwischen zwei und sechs Wochen dauern kann, ein qualitativ hochwertiges Minimum Viable Product liefern, das voll funktionsfähig und getestet ist. Dies bedeutet, dass wir sicherstellen müssen, dass wir die Qualität der Produktsoftware bei jedem Schritt und in jedem Sprint aufrechterhalten. Produkte, die mit den agilen Methoden entwickelt wurden, werden häufiger getestet. Dies bedeutet jedoch auch, dass sie ständige Regressionstests benötigen, um sicherzustellen, dass ein Update die in früheren Builds getesteten und übergebenen Funktionen nicht beeinträchtigt.
Wie halten Entwickler die Qualität des Softwarecodes aufrecht?
Ein guter Entwickler ist einer, der qualitativ hochwertigen Softwarecode mit minimalen Fehlern liefern kann. Wir sagen ‚minimal‘, weil während der Entwicklung einige Fehler unvermeidlich sind und es darauf ankommt, wie wir sie beheben oder kontrollieren. Aus diesem Grund messen Entwickler ihre Codequalität während der Entwicklung, da sie so Probleme während des Builds identifizieren und beheben können. Sie messen ihren Code anhand von Codierungsstandards, Code-Reviews, Code-Analysatoren und Refraktor-Legacy-Code.
In diesem Stadium wird die Softwarequalität manuell mit kurzen Komponententests getestet. Ein Komponententest ist die erste Stufe der Softwarequalitätsmessung, bei der der kleinste testbare Teil der Software – ein Modul oder eine Komponente des Programms oder sogar eine einzelne Funktion innerhalb des Codes – überprüft wird.
Beispielsweise kann es eine Reihe von Datenfeldern geben, die als Teil einer größeren Software ausgefüllt werden müssen. Ein Komponententest kann nur das erste Feld und nicht die anderen oder einen anderen Teil des Softwareprogramms testen.
Die Entwickler erstellen eine gemeinsam genutzte Bibliothek mit Hunderten solcher Tests, wobei wiederholbare Funktionen in die Software eingebettet sind, sodass diese Tests projektübergreifend immer wieder verwendet werden können, um Fehler im Softwarecode in der Entwicklungsphase effizient zu erkennen. Sie führen auch automatisierte Tests mit einem Code-Analysator, SonarQube, durch, der Software auf:
- Klarheit
- Wartbarkeit
- Dokumentation
- Erweiterbarkeit
- Effizienz
- Getestet
- Sichere Codierung
- Code-Refactoring
- Erweiterbarkeit
Es hilft uns:
- Führen Sie Code Reviews durch
- Pflegen Sie Codierungsstandards
- Identifizieren Sie Fehler und die Anzahl potenzieller Fehler in der Software
Wir verwenden es auch zur Bewertung:
- Die strukturelle Komplexität des Programms (Anzahl der Codezeilen)
- Alle in Repositorys gefundenen Schwachstellen
- Code riecht (Code, der verwirrend oder schwer zu pflegen ist)
- Codeabdeckung (Maß für den Code, der von Komponententests abgedeckt wird)
- Code-Duplizierung (Menge des Codes, der wiederholt)
Wie misst das QS-Team die Softwarequalität?
QA-Tester überprüfen alle Metriken der Softwarequalität durch manuelle und automatisierte Tests (mit Selenium), einschließlich der Gültigkeit und des Standards des Produktcodes. Manuelle Testmetriken können in zwei Klassen unterteilt werden – Basismetriken und berechnete Metriken. Basismetriken bestehen aus den rohen, nicht analysierten Daten, die erfasst werden, während berechnete Metriken aus den Informationen abgeleitet werden, die in den Basismetriken erfasst wurden.
Manuelle Testmetriken
Einige der wichtigen manuellen Testmetriken, die wir für die Softwarequalität berücksichtigen, sind:
- Produktivitätsmetriken für die Testfallausführung
- Produktivitätsmetriken für die Testfallvorbereitung
- Testdauer
- Unit-Testabdeckung (die Menge an Softwarecode, die von Unit-Tests abgedeckt wird)
- Prozentsatz der bestandenen / nicht bestandenen Tests usw.
Automatisierungstestmetriken
Automatisierungstests können dazu beitragen, den manuellen Zeitaufwand für das Testen der Softwarequalität zu reduzieren. Hier sind einige der wichtigen Metriken für Automatisierungstests, die wir berücksichtigen:
- Gesamtdauer des Tests
- Unit-Testabdeckung
- Pfadabdeckung (wie viele linear unabhängige Pfade des Programms der Test abdeckt)
- Anforderungsabdeckung
- Bestandener / nicht bestandener Prozentsatz der Tests
- Anzahl der Fehler
- Prozentsatz der Fehler
- Testausführung (gesamte während des Builds ausgeführte Tests)
- Nützliche vs. irrelevante Ergebnisse
- Defekte in der Produktion
- Prozentsatz defekter Builds usw.
Andere Arten von Tests zur Messung der Softwarequalität
Wir verwenden auch verschiedene Arten von Tests, um die Softwarequalität zu messen. Dies sind:
- Funktionstests
- Testen, um zu brechen
- Lastleistungstests
- Regressionstests
- Sicherheitstests
- Penetrationstests
- Benutzerakzeptanztests