hoe meten we softwarekwaliteit
voordat we een softwareproduct kunnen leveren, moeten we de kwaliteit ervan meten om ervoor te zorgen dat het zo foutloos is als we het mogelijk kunnen maken. Echter, om dit te doen, moeten we eerst weten tegen welke software kwaliteit metrics we meten.
Wat zijn de maatstaven voor het meten van softwarekwaliteit?
de gegevens voor het meten van de softwarekwaliteit kunnen uiterst technisch zijn, maar kunnen worden onderverdeeld in de volgende vier essentiële categorieën:
- codekwaliteit
- prestatie
- beveiliging
- bruikbaarheid
codekwaliteit
Bug-vrije en semantisch correcte code is zeer belangrijk voor premiumsoftware. De kwaliteitsstandaarden van de Code kunnen worden onderverdeeld in kwantitatieve en kwalitatieve metrics. Kwantitatieve kwaliteitsstatistieken meten hoe groot of complex het softwareprogramma is, het aantal regels en functies dat het bevat, hoeveel bugs er per 1.000 regels code zijn en meer. Kwalitatieve code kwaliteit metrics meten functies zoals onderhoudbaarheid, leesbaarheid, duidelijkheid, efficiëntie en documentatie. Deze metrics meten hoe gemakkelijk de code is te lezen, te begrijpen, en of het is geschreven volgens coderingsnormen.
Performance
elk softwareprogramma is gebouwd voor een bepaald doel. Prestatiemetingen meten of het product voldoet aan zijn doel en of het presteert zoals het bedoeld is. Het verwijst ook naar hoe de applicatie resources gebruikt, de schaalbaarheid, klanttevredenheid en responstijden.
beveiliging
Softwarebeveiligingsstatistieken meten de inherente veiligheid van een softwareprogramma en zorgen ervoor dat er geen ongeoorloofde wijzigingen in het product optreden wanneer het aan de klant wordt overhandigd.
Usability
aangezien alle softwareproducten zijn gebouwd voor een eindgebruiker, is het van belang of het programma uitvoerbaar en gebruiksvriendelijk is. We zorgen er ook voor dat de klant tevreden is met de functies en prestaties.
Wanneer Meten We De Softwarekwaliteit?
ons software development team en Quality Assurance (QA) team werken samen om ervoor te zorgen dat de softwarekwaliteit van de hoogste standaard is. Het QA team doet producttesten, eenmaal ontwikkeld. Echter, de ontwikkeling team ook onderhoudt, maatregelen, en voortdurend verbetert de kwaliteit van de software tijdens de bouw. Hoewel we de softwarekwaliteit in elke ontwikkelingsfase behouden, kunnen we ze op verschillende punten in de ontwikkeling testen, op basis van de gebruikte ontwikkelingsmethodologie. We gebruiken twee methodologieën bij het ontwikkelen van softwaretoepassingen – Waterfall en Agile. Aangezien de twee methodologieën het product op verschillende manieren leveren, worden ze ook anders getest.
softwarekwaliteit meten: Watervalmethodologie
Watervalmethodologie is wanneer we plannen, uitvoeren, testen en leveren in verschillende fasen. Elke fase is voltooid voordat de volgende begint. Als gevolg hiervan, met een product ontwikkeld met behulp van deze methodologie, moeten we de kwaliteit van het product te behouden in elke fase – eisen, ontwerp, implementatie, verificatie (of testen), en onderhoud. Aangezien het testen aan het einde van de build wordt gedaan, kost het minder tijd en vereist het niet veel regressie testen.
het meten van softwarekwaliteit: Agile
de Agile-methoden zijn responsiever en flexibeler, waarbij de ontwikkeling in fasen of sprints wordt opgesplitst. Het doel is dat we aan het eind van elke sprint, die tussen de twee en zes weken kan duren, een kwalitatief hoogwaardig minimaal levensvatbaar product leveren dat volledig functioneel en getest is. Dit betekent dat we ervoor moeten zorgen dat we de kwaliteit van productsoftware behouden bij elke stap, in elke sprint. Producten ontwikkeld met behulp van de Agile methodologieën worden vaker getest. Echter, het betekent ook dat ze constant regressie testen om ervoor te zorgen dat een update niet de functionaliteiten die werden getest en doorgegeven in eerdere builds heeft gebroken.
hoe behouden ontwikkelaars de kwaliteit van de softwarecode?
een goede ontwikkelaar is iemand die softwarecode van hoge kwaliteit kan leveren met minimale bugs. We zeggen ‘minimaal’ omdat, tijdens de ontwikkeling, sommige bugs onvermijdelijk zijn en waar het om gaat is hoe we ze repareren of controleren. Dat is de reden waarom ontwikkelaars meten hun code kwaliteit als ze ontwikkelen, omdat het betekent dat ze kunnen identificeren en problemen op te lossen tijdens de bouw. Ze meten hun code aan coderingsnormen, codebeoordelingen, codeanalysatoren en legacy-code van de refractor.
in dit stadium wordt de softwarekwaliteit handmatig getest met korte unit tests. Een unit test is de eerste fase van de software kwaliteitsmeting, waarbij het kleinste testbare deel van de software – een module of onderdeel van het programma of zelfs een enkele functie binnen de code – wordt gecontroleerd.
er kunnen bijvoorbeeld een aantal gegevensvelden zijn die moeten worden ingevuld als onderdeel van een grotere software. Een unit test kan alleen het eerste veld testen en niet de anderen, of zelfs elk ander deel van het softwareprogramma.
de ontwikkelaars maken een gedeelde bibliotheek van honderden van dergelijke tests, met herhaalbare functionaliteit ingebed in de software, zodat deze tests kunnen worden gebruikt over en weer, over projecten voor het efficiënt detecteren van fouten in de softwarecode in de ontwikkelingsfase. Ze voeren ook geautomatiseerd testen met behulp van een code analyser, SonarQube, die controleert of software voor:
- Duidelijkheid
- Onderhoud
- Documentatie
- uitbreidbaarheid naar
- Efficiëntie
- Goed getest
- Secure coding
- Code refactoring
- uitbreidbaarheid naar
Het helpt ons:
- Gedrag van code reviews
- Handhaven coding standards
- Identificeren van fouten en het aantal potentiële fouten in de software
We gebruiken het ook om te beoordelen:
- de structurele complexiteit van het programma (aantal regels code)
- eventuele kwetsbaarheden in repositories
- codegeuren (code die verwarrend of moeilijk te onderhouden is)
- codedekking (mate van code die door eenheidstests wordt gedekt)
- codeduplicatie (hoeveelheid code die wordt herhaald)
hoe meet het QA Team de kwaliteit van de Software?
QA testers beoordelen alle metrics van de softwarekwaliteit door middel van handmatige en geautomatiseerde testen (met behulp van Selenium), met inbegrip van de geldigheid en standaard van de productcode. Handmatige test metrics kan worden onderverdeeld in twee klassen – basis metrics en berekende Metrics. Base metrics zijn samengesteld uit de ruwe, niet-geanalyseerde gegevens die worden verzameld, terwijl de berekende metrics zijn afgeleid van de informatie die werd verzameld in de base metrics.
handmatige Testmetrics
enkele van de belangrijke handmatige testmetrics die we overwegen voor softwarekwaliteit zijn:
- uitvoering van testcases productiviteitsmetingen
- voorbereiding van testcases productiviteitsmetingen
- duur van Test
- dekking van Testeenheden (de hoeveelheid softwarecode die wordt bestreken door tests per eenheid)
- geslaagd/mislukt percentage tests, enz.
Automatiseringstestmetrics
automatiseringstests kunnen helpen de hoeveelheid handmatige tijd die wordt besteed aan het testen van softwarekwaliteit te verminderen. Hier zijn enkele van de belangrijke statistieken voor automatisering testen die we overwegen:
- Totale duur van de test
- Unit test coverage
- Pad dekking (hoeveel lineair onafhankelijke paden van het programma de test heeft)
- Vereisten dekking
- Pass/fail percentage van tests
- Aantal gebreken
- Percentage van geautomatiseerde test-dekking (tegen de totale test dekking omvat handmatig testen)
- de uitvoering van de Test (totaal tests uitgevoerd tijdens de bouw)
- Handige vs. irrelevante resultaten
- Gebreken in de productie
- Percentage van de afgebroken gebouwen, enz.
andere soorten Tests voor het meten van softwarekwaliteit
we gebruiken ook verschillende soorten tests om softwarekwaliteit te meten. Deze zijn:
- functionele tests
- Breuktest
- belastingtest
- regressietest
- veiligheidstesten
- penetratietest
- acceptatietest