---
title: "Software reliability and reliability models"
subject: "Software Engineering"
chapter: 9
key: "semester_5/software_engineering:reliability-models"
source: https://www.bctengineer.com/q/semester_5/software_engineering/reliability-models
site: BCT Engineering
---

# Software reliability and reliability models

Software Engineering · Chapter 9: Quality management

- Asked in: 2070 Chaitra (old course), 3+7 marks; 2067 Ashadh (old course), 4 marks (asked 2 times)
- Video: [Software Reliability Models | Software Engineering-II](https://www.youtube.com/watch?v=wT8oNWg0kec) — Sami Aqeel
- Answer checked by Claude Opus 5.5 (high effort) on 2026-10-14
- Page: https://www.bctengineer.com/q/semester_5/software_engineering/reliability-models
- Whole chapter: https://www.bctengineer.com/md/semester_5/software_engineering/chapter-9

## Question

Define the software reliability. Explain the software reliability models with example.

## Short answer

Software reliability is the probability of failure-free operation in a specified environment for a specified time. Key models are Jelinski-Moranda equal-step, Littlewood-Verrall random-step, Musa basic exponential, and Musa-Okumoto logarithmic Poisson, used to predict reliability growth during testing.

## Answer

#### Software reliability

**Software reliability** is the probability of failure-free operation of a computer program in a specified environment for a specified time (Musa). For example, if a program has a reliability of 0.97 over 8 hours of operation, then in 100 runs of 8 hours each it is expected to work without failure in about 97 of them.

Common reliability metrics:
- **MTTF** (mean time to failure) and **MTBF** = MTTF + MTTR (mean time to repair).
- **Availability** = MTTF / (MTTF + MTTR) × 100%.
- **ROCOF** (rate of occurrence of failures) and **POFOD** (probability of failure on demand).

If the failure rate λ is constant, reliability over time t is R(t) = e^(−λt). For λ = 0.002 failures/hour and t = 100 hours, R = e^(−0.2) ≈ 0.82.

#### Software reliability models

Software does not wear out; its reliability improves as faults are found and removed during testing and use. **Reliability growth models** describe this improvement and are used to predict when the required reliability will be reached, so the team knows when to stop testing.

**1. Equal-step function model (Jelinski–Moranda)**
- Assumes the program starts with N faults, every fault contributes equally to the failure rate, and each fix removes exactly one fault without adding new ones.
- So reliability increases by an equal step after every repair.
- Failure rate after (i − 1) faults are removed: λi = φ (N − i + 1), where φ is the failure rate contributed by one fault.

Example: N = 50 faults, φ = 0.01 failures/hour per fault.
- At the start: λ = 0.01 × 50 = 0.5 failures/hour, MTTF = 1/0.5 = 2 hours.
- After 30 faults are removed: λ = 0.01 × 20 = 0.2 failures/hour, MTTF = 5 hours.

**2. Random-step function model (Littlewood–Verrall)**
- More realistic: fixing a fault changes reliability by a random amount, because faults differ in how often they occur, and a repair may introduce new faults.
- Reliability usually rises, but sometimes it falls after a fix.

```text
Reliability              Equal-step model:
  ^              ____    each fix raises
  |         ____|        reliability by the
  |    ____|             same amount
  |___|
  +------------------> faults fixed

Reliability              Random-step model:
  ^             __       each fix changes
  |      __    |  |__    reliability by a
  |  ___|  |___|         random amount; it
  |_|                    may even fall
  +------------------> faults fixed
```

**3. Continuous (exponential) models: Musa's basic execution time model**
- Failure intensity falls linearly with the number of failures experienced:
  λ(μ) = λ0 (1 − μ / ν0)
  where λ0 = initial failure intensity, μ = failures experienced so far, ν0 = total failures expected in infinite time.

Example: λ0 = 10 failures/CPU hour, ν0 = 100. After μ = 50 failures, λ = 10 × (1 − 50/100) = 5 failures/CPU hour.

**4. Logarithmic Poisson model (Musa–Okumoto)**
- Early fixes give a large improvement and later fixes give smaller ones:
  λ(μ) = λ0 e^(−θμ), where θ is the failure intensity decay parameter.

Example: λ0 = 10, θ = 0.02, μ = 50: λ = 10 × e^(−1) ≈ 3.68 failures/CPU hour.

**Other classification**
- **Prediction models** use historical data from earlier projects, before testing starts.
- **Estimation models** use failure data from the current project's testing.

**Use in practice:** the system is tested with an **operational profile** (inputs in the same proportion as real use), failure times are recorded, a model is fitted to the data, and the predicted reliability is compared with the required value (for example ROCOF ≤ 2 failures per 1000 hours) to decide whether to release.

## Check yourself

The answer's key points as multiple-choice questions, with the correct option and why.

1. What is software reliability?
   A. The size of the program
   B. The speed of the program
   C. The number of developers
   D. The probability of failure-free operation in a specified environment for a specified time
   Answer: D. Musa defines reliability as the probability of failure-free operation for a specified time in a specified environment. (Key point: Definition of reliability)

2. In the Jelinski-Moranda model with N = 50 and phi = 0.01, what is the failure rate after 30 faults are removed?
   A. 0.5 failures/hour
   B. 0.2 failures/hour
   C. 0.3 failures/hour
   D. 0.01 failures/hour
   Answer: B. 20 faults remain, so lambda = 0.01 x 20 = 0.2 failures/hour (MTTF 5 hours). (Key point: Jelinski-Moranda model)

3. How does the random-step (Littlewood-Verrall) model differ from the equal-step model?
   A. Each fix changes reliability by a random amount, and reliability may even fall
   B. Every fix raises reliability by exactly the same amount
   C. Reliability never changes
   D. It assumes there are no faults
   Answer: A. Faults differ in how often they occur and repairs may add new faults, so the change per fix is random. (Key point: Equal-step vs random-step)

4. With lambda0 = 10 failures/CPU hour and nu0 = 100, what is the failure intensity after 50 failures in Musa's basic model?
   A. 10
   B. 2.5
   C. 5
   D. 3.68
   Answer: C. lambda = lambda0(1 - mu/nu0) = 10 x (1 - 0.5) = 5 failures/CPU hour. (Key point: Musa basic model)

## Related in Software Engineering

- [Why software reliability matters](https://www.bctengineer.com/question.md?key=semester_5%2Fsoftware_engineering%3Areliability-importance) — Software Engineering, chapter 9
- [Current process models; why waterfall is not accurate](https://www.bctengineer.com/question.md?key=semester_5%2Fsoftware_engineering%3Awaterfall-not-accurate) — Software Engineering, chapter 1
- [Alternative models to waterfall](https://www.bctengineer.com/question.md?key=semester_5%2Fsoftware_engineering%3Aalternative-to-waterfall) — Software Engineering, chapter 1

## Related in other subjects

- [Compare software models; propose a fourth model](https://www.bctengineer.com/question.md?key=semester_5%2Finstrumentation_ii%3Asw-models-compare-fourth) — Instrumentation II, chapter 9
- [Software reliability; waterfall vs prototyping; embedded software](https://www.bctengineer.com/question.md?key=semester_5%2Finstrumentation_ii%3Asw-reliability-models-embedded) — Instrumentation II, chapter 9
- [Software process models and effort estimation](https://www.bctengineer.com/question.md?key=semester_5%2Finstrumentation_ii%3Asw-process-models) — Instrumentation II, chapter 9, asked 2×
- [Shortcomings of software development models](https://www.bctengineer.com/question.md?key=semester_5%2Finstrumentation_ii%3Asw-model-shortcomings) — Instrumentation II, chapter 9