Software Engineering Tutorial

Introduction SDLC

SDLC Models

Agile Model Big-bang Model Incremental Model Iterative Model Prototype Model RAD Model Spiral Model V-Model Waterfall Model Open Source Development Model

Software Management

Project Management Project Management Activities Project Management Tools

Software Metrics

Software Quality Metrics Halstead's Software Metrics Object Oriented Metrices Data Structure Metrics Overall Equipment Effectiveness Some Important Quality Metrics

Project Planning

Software project planning Cost Estimation Model

Software Configuration

Software Configuration Management Project Monitoring and Control

System Design

Strategies for System Design Caching in System Design Load Balancer – System Design Dropbox - System Design Netflix - System Design Twitter - System Design

Misc

Routing Requests through Load Balancers Object Oriented Analysis and Design in Software Engineering Online Library Management System ER Diagram in Software Engineering Umbrella Activities in Software Engineering Jelianska Moranda Software Relability Model RAD Model vs SDLC Model Software Myths in Software Engineering What is Capability Maturity Model Characteristics of Software Engineering Characteristics of Good Design in Software Engineering Program Analysis Tools in Software Engineering Reactive and Proactive Software Risk Management in Software Engineering Size-Oriented Metrics in Software Engineering Software Requirements and their Types in Software Engineering Structured Programming in Software Engineering System Development Life Cycle in MIS Difference between V Model and Waterfall Model Overview of Fish SDLC Model

Jelianska Moranda Software Relability Model

One of the first software reliability models is the Jelinski-Moranda (J-M) model. This fundamental paradigm is the basis for numerous existing software reliability models.

Assumption:-

The following is a list of the model's assumptions:

  • The number of initial errors in the program is N, which is an unknowable but fixed constant.
  • Each programming error is distinct and equally likely to result in a test failure.
  • The elapsed times between failures are independent of one another.
  • Every time a failure happens, a matching fault is unquestionably fixed.
  • It is expected that the fault that results in a failure is immediately fixed and that no additional faults are introduced while the identified fault is fixed.
  • The frequency of software failures throughout a failure period is constant and inversely correlated with the number of program flaws still present.

The contribution of any one fault to the whole program is provided by $$ lambda (t i)= phi [N-(i-1)],; i=1, 2,..., N$$, where $phi $ is a proportional constant. N is the total number of initial errors in the program, and $t i$ is the interval of time between failures $(i-1)th and $(i)th.

For instance, the failure intensity starts out as $$lambda (t 1)=phi N$$ and then reduces to $$lambda (t 2)=phi (N-1)$$ after the first failure, and so on. f(t i)=phi [N-(i-1)] is the partial distribution function (pdf) of $t i$.
Phi (N-(i-1))t i, e-phi F(t i)=1- e- phi [N-(i-1)]t i is the cumulative distribution function (cdf) for the integer $t i. Thus, the software reliability function is R(t i)=e-phi (N-i+1)t i.

The model of mathematics which works to forecast the system's reliability software model over a particular time, is called the Jelinska Moranda Model. The model makes the assumption that the software system may be modeled as a collection of separate components, each with a unique failure rate. Each component's failure rate is anticipated to remain constant throughout time.

By preferring the given time t JM model uses the following equation to calculate software reliability:

R(t) = R(0) * exp(-λt)

In above equation, R(t) is the reliability of the software system at time t, R(0) is the software system's initial reliability, the system's failure rate, and t is the length of time since the program was first used.

Characteristics of JM Model:-

  • The model is a Binomial one.
  • The original and most well-known black-box model.
  • The J-M model always produces an overly optimistic forecast of dependability.
  • JM Model goes through a perfect debugging process, in which the found flaw is eliminated using a simple certainty model.

The following equation is used to measure the rate of constant failure occurring in the JM model at the ith interval:

 λ(ti) = ϕ [N-(i-1)], i=1, 2... N .........equation 1

The JM model is predicated on the following number of things:

  • Modeling the software system as a collection of separate parts, each with a fixed failure rate, is possible.
  • Over time, the failure rate remains constant.
  • A Poisson process can be used to model failures.
  • The dependability of one component has no bearing on the dependability of the others.
  • The JM model is commonly used in software engineering to make software testing and maintenance choices and anticipate the dependability of software systems. It has drawn flak, meanwhile, for being overly simplistic and basing assumptions on software systems that are unfounded. Yet, it continues to be a helpful tool for software developers and can offer insightful information about the dependability of software systems.

Jelinski-Moranda (JM) software reliability model benefits:

  1. JM model's simplicity and readability make it an effective tool for software engineers without extensive experience in mathematical modeling.
  2. The JM model is extensively used in software engineering and has been applied to a variety of software systems.
  3. Predictability: The JM model can offer insightful information on how long-term software systems' dependability, assisting software engineers in making knowledgeable choices about software testing and maintenance.

There are various downsides to the Jelinski-Moranda (JM) software dependability paradigm: -

  1. Unrealistic assumptions: The JM model involves a number of illogical assumptions about software systems, such as the notion that failures can be characterized as a Poisson process with a constant failure rate over time.
  2. The JM model has a narrow range of applications and might need to be revised for more complicated software systems.
  3. Lack of adaptability: The JM model has limitations when it comes to accounting for the dynamic nature of software systems, such as environmental changes or the introduction of new functionality.