Waarop is de gradatie van het ernstniveau van fouten…

De gradatie van het niveau van ernst (severity) van fouten hangt af van de impact van het defect op functionaliteit, stabiliteit of veiligheid van het softwareproduct. Er wordt de potentiële schade voor de gebruiker of het bedrijf beoordeeld.

Belangrijke factoren die de severity beïnvloeden:

Kritiekheid van de functionaliteit: Hoe belangrijk is de getroffen functie voor de werking van de applicatie.
Impact op hoofdoperaties: Belemmeren het defect het uitvoeren van kernactiviteiten?
Verlies van gegevens of geld: Kan het defect leiden tot datalekken of verlies, evenals financiële verliezen.
Beschikbaarheid van het systeem: Blokkeert het defect volledig of gedeeltelijk het gebruik van de applicatie.
Mogelijkheid tot omzeiling: Is er een alternatieve manier om de actie uit te voeren?
Frequentie van voorkomen: Hoe vaak manifesteert het defect zich (hoewel dit meer een prioriteitsfactor is, kan het ook de severity beïnvloeden als het defect kritisch en constant is).

Typische severity-niveaus (kunnen variëren afhankelijk van het project en het bedrijf):

Blocker: Het product is volledig onbruikbaar, kritische functionaliteit is geblokkeerd, voortzetten van werk of testen is onmogelijk. Gegevensverlies of financiële verliezen zijn gegarandeerd.
Critical: Kritisch belangrijke functionaliteit werkt niet of werkt onjuist. Belangrijke operaties zijn ernstig verstoord, maar gedeeltelijk werken is mogelijk. Er is geen omweg.
Major: Belangrijke maar niet kritische functionaliteit werkt niet of onjuist. Er kunnen onderbrekingen zijn in hoofdoperaties, maar er is een omweg. Gegevensverlies kan voorkomen, maar niet kritisch.
Minor: Onbeduidende verstoringen in functionaliteit of gebruiksvriendelijkheid. Heeft geen invloed op hoofdoperaties. Een eenvoudige omweg is beschikbaar.
Trivial: Cosmetische defecten, tekstfouten, die de functionaliteit niet beïnvloeden.

enum DefectSeverity {
    case blocker, critical, major, minor, trivial
}

func determineSeverity(defectFunctionality: FunctionalityLevel, impact: ImpactLevel) -> DefectSeverity {
    switch (defectFunctionality, impact) {
    case (.critical, .blocksAll): return .blocker // Kritische functie, blokkeert volledig
    case (.critical, .majorIssue): return .critical // Kritische functie, ernstige problemen
    case (.essential, .blocksAll): return .critical // Belangrijkste functie, blokkeert volledig
    case (.essential, .majorIssue): return .major // Belangrijkste functie, ernstige problemen
    case (_, .minorIssue): return .minor // Kleine problemen
    case (_, .cosmetic): return .trivial // Cosmetische problemen
    default: return .minor // Standaardwaarde
    }
}

enum FunctionalityLevel {
    case critical, essential, minor
}

enum ImpactLevel {
    case blocksAll, majorIssue, minorIssue, cosmetic
}

// Gebruik:
let severity = determineSeverity(defectFunctionality: .critical, impact: .blocksAll)
print(severity) // Zal tonen: blocker

Waarop is de gradatie van het ernstniveau van fouten (severity) gebaseerd?