UNIT- 1

1. Software Quality:

Software quality product is defined in term of its fitness of purpose. That is, a quality product
does precisely what the users want it to do. For software products, the fitness of use is
generally explained in terms of satisfaction of the requirements laid down in the SRS
document. Although "fitness of purpose" is a satisfactory interpretation of quality for many
devices such as a car, a table fan, a grinding machine, [Link] software products, "fitness of
purpose" is not a wholly satisfactory definition of quality.

Example: Consider a functionally correct software product. That is, it performs all tasks as
specified in the SRS document. But, has an almost unusable user interface. Even though it
may be functionally right, we cannot consider it to be a quality product.

The modern view of a quality associated with a software product several quality
methods such as the following:

Portability: A software device is said to be portable, if it can be freely made to work in

various operating system environments, in multiple machines, with other software products,
etc.

Usability: A software product has better usability if various categories of users can easily
invoke the functions of the product.

Reusability: A software product has excellent reusability if different modules of the product
can quickly be reused to develop new products.

Correctness: A software product is correct if various requirements as specified in the SRS

document have been correctly implemented.

Maintainability: A software product is maintainable if bugs can be easily corrected as and

when they show up, new tasks can be easily added to the product, and the functionalities of
the product can be easily modified, etc.

2. Software Quality Attribute :

Software Quality is a term used to measure the degree of excellence of software. Software Quality
attributes are extremely important while designing a software application.
There is a misconception that if the software application is bug-free then the quality of the software is
high. However, a bug-free product is just one of the Software Quality Attributes. The quality of the
software also depends on the user requirements, satisfaction, clearer design, usability, etc.

List of Software quality attributes

Software Quality attributes help to measure the quality of the software from different angles. Software
Quality Attributes can be broadly classified into 5 types: Design, Runtime, System, User, and Non-
runtime qualities. However, when we go into detail there are at least 14 different attributes. Let’s discuss
this in detail.

Reliability
Reliability is the ability of software applications to behave as expected and function under the maximum
possible load.
Reliability is made up of different types
● Availability: The percentage of time the application is available for use. 100% availability refers to
the system being always available and never going down under any circumstances.
● Recoverability: Recoverability refers to the ability to recover the system quickly and efficiently.
● Fault Tolerance: This attribute refers to the extent to which the system can tolerate hardware
failures.
Let’s take an example of an e-commerce website. The website went down as one of the server nodes
crashed. In an ideal situation, if the reliability attribute is implemented then the system should
automatically failover to the other server node.

Maintainability
Maintainability refers to how easily software developers can add new features and update existing
features with new technologies. The application architecture plays a critical role in maintainability. The
well-architected software makes maintenance easier and more cost-effective.
Consider the scenario where the law enforces new privacy laws. If your software is running on legacy
code, adhering to new laws might be challenging. If the software is well-architected and the code is well
documented, implementing such changes would be an easy task.

Usability
The Usability attributes refer to the end user’s ease of use. Usability is tied to application performance,
application UX design, and accessibility. To understand usability better let’s consider an e-commerce
page – user has purchased an item and wants to return the item. Good usability makes the return option
available on the orders page. In some cases, the return option may appear on to contact us page – in this
situation user easily gets confused and faces difficulty to find the return option.
The usability design principles can help to design a good customer experience. The meaningful option
texts, tooltips, and info icons are a great way to encourage self-learning.

Portability
The portability quality attribute refers to how easily the system can be ported or migrated to other
environments containing different hardware or operating system specifications. The portability problem is
majorly faced in mobile native applications.
An example of a portability issue – you have designed a web application that works perfectly fine on
Android devices but when it is ported to iPhone devices (iOS), it fails to render. If your application is
abstracted from UI and business logic, fixing such issues becomes easy.

Correctness
Correctness refers to the ability to behave or function as per software requirement specifications. This
may include navigations, calculations, form submissions, etc.
Consider an example of sign-up. Your application should navigate to the terms and conditions page after
signing up as per the requirement specification. However, it is landing on the home page without showing
the terms and conditions page. Strict code reviews checklist and Unit testing can help to discover such
bugs.

Efficiency
Efficiency can be defined as the time taken by the system to complete a specific task. In layman’s terms,
it can be the performance of the application. Performance is the most critical software quality attribute as
it can make the user system to a hung state. The utilization of system resources should be taken care
with the most efficient way, and any memory leaks should be avoided to achieve high efficiency.
For example, if you open one of the video editor applications on your desktop, as soon as you open your
system freezes, and all the other open application start to behave in an unintended way. This is a bad
application design and shows the poor efficiency of the software.
Security
Security attribute focuses on the ability to safeguard applications, data, and information from unauthorized
entities. This is very crucial as the data leaks may incur huge losses in terms of organization’s brand
name and reputation. Furthermore, the organization may face a lawsuit.
Authentication, authorization, and data encryption are a few key areas that can safeguard from malicious
attacks. Add on to this, if your application is B2C, educating customers also plays an important role.
An example of a security attribute is, you have developed an API endpoint that is exposed to the public
however, there is no authorization required to access this endpoint. This can make API and the underlying
system, less secure. To make the API secure you can consider enabling a JWT security token as
mandatory, which can be created only by authorized users.

Testability
Testability is how easily QA members can test the software and log a defect and how easy it is to
automate the software applications. Your application design should focus on making the testing easier
and faster.
Consider an example, you have designed a web application that doesn’t contain any uniquely identifiable
locators. This makes automation more complicated. Adding ids, data-testid, and class helps to cover more
scenarios through automation.
Here is a guide that talks in detail about the quality assurance in software testing
Learn more

Nowadays automation testing is most recommended as it makes the delivery faster. If your application
is automation friendly then one can easily automate the application using automation software like
Testsigma and identify the defects in the early stage.

Flexibility
Technology changes are more common nowadays. Flexibility refers to how quickly your application can
adapt to future and current technology demands. Indirectly the flexibility attribute is tied up with your
competency in the market. If your application is not up to date with the latest technology then you might
not be able to deliver all the user needs.
For example, You are using a third-party library for styling your application. Due to some reasons, the
third-party library declares the end of development. Now the question arises of how quickly your
application can switch to another library. If it takes longer, then it might cost your business.
Never develop applications with tight coupling of libraries you have reference to, rather design
applications in a generic manner and hook the libraries.

Scalability
Scalability is how easily your system can handle increasing demands without affecting the application’s
performance. Vertical Scalability and Horizontal Scalability are two primary areas that help to meet the
scalability criteria.
For example, an e-commerce website declares a Black Friday sale. On sale day, the application sees
huge traffic. If your application is designed according to the scalability attribute, as soon as the traffic
increases, the system should automatically add the server nodes and distribute the traffic. Failing to do
that may result in your application going down.

Compatibility
Compatibility focuses on the ability to work software systems on different operating systems, and
browsers seamlessly as expected without affecting any functionality.
A most common problem with the web application where it works on Chrome but it doesn’t on Firefox.
This is because of compatibility issues. When it comes to business, you can’t restrict users to use a
specific browser. However, such issues can be tested using the most popular tools like Testsigma.
Testsigma provides 3000+ real devices and multiple browsers to execute your automated tests for
compatibility testing. Using such automation tools helps to discover compatibility issues at an early
stage.

Supportability
It is the degree to which a software system can provide useful information for identifying and resolving the
issues when application/functionality stops working. Enabling logging, monitoring, and health checks are
most useful to adapt supportability.
For Example, Your application has a profile information page, which works perfectly fine for some users
and only a few users are facing issues with the profile page. In this case, it is difficult to reproduce in a
lower-level environment. The logs come in handy to identify the call stack and reference APIs which is
causing the issue.

Reusability
It is the degree to which software components can be reused in another application or the same
application. Reusable software components reduce the development cost and effort. This is one of the
reasons most companies are encouraging component-based development.
For example, your organization is developing two different applications where both the application needs
sign-in and sign-up forms. If you don’t have a reusable components strategy then you need to develop the
same thing two times. On the other hand, if you have identified common components and designed those
as reusable and shareable components it would be much easier to integrate sign-in and sign-up screens
into both the application. The reusable component can also decrease maintenance costs.

Interoperability
Interoperability refers to the ability to communicate or exchange data between different systems. Which
can be operating systems, databases, or protocols. The interoperability problem arises due to the legacy
code base, poorly architectured application, and poor code quality.
For example, Your application needs to communicate with the payment gateway but you are facing
challenges to integrate with the payment gateway due to various standards mismatch. If you had taken all
the security, data, and standard API design approach this wouldn’t have happened.

3. Cost of Quality:

It is the most established, effective measure of quantifying and calculating the

business value of testing. There are four categories to measure cost of quality:
Prevention costs, Detection costs, Internal failure costs, and External failure costs.
These are explained as follows below.
1. Prevention costs include cost of training developers on writing secure
and easily maintainable code
2. Detection costs include the cost of creating test cases, setting up testing
environments, revisiting testing requirements.
3. Internal failure costs include costs incurred in fixing defects just before
delivery.
4. External failure costs include product support costs incurred by
delivering poor quality software.

4. Defects, faults, failure:

What is a bug?
In software testing, a bug is the informal name of defects, which means that software or
application is not working as per the requirement. When we have some coding error, it leads
a program to its breakdown, which is known as a bug. The test engineers use the
terminology Bug.

If a QA (Quality Analyst) detect a bug, they can reproduce the bug and record it with the
help of the bug report template.

What is a Defect?
When the application is not working as per the requirement is knows as defects. It is
specified as the aberration from the actual and expected result of the application or
software.

In other words, we can say that the bug announced by the programmer and inside the
code is called a Defect.

What is Error?
The Problem in code leads to errors, which means that a mistake can occur due to the
developer's coding error as the developer misunderstood the requirement or the
requirement was not defined correctly. The developers use the term error.

What is Fault?
The fault may occur in software because it has not added the code for fault tolerance,
making an application act up.

A fault may happen in a program because of the following reasons:

○ Lack of resources

○ An invalid step

○ Inappropriate data definition

What is Failure?
Many defects lead to the software's failure, which means that a loss specifies a fatal issue
in software/ application or in its module, which makes the system unresponsive or broken.

In other words, we can say that if an end-user detects an issue in the product, then that
particular issue is called a failure.

Possibilities are there one defect that might lead to one failure or several failures.

For example, in a bank application if the Amount Transfer module is not working for end-
users when the end-user tries to transfer money, submit button is not working. Hence, this
is a failure.

The flow of the above terminologies are shown in the following image:

Bug Vs. Defect Vs. Error Vs. Fault Vs. Failure

We have listed some of the vital differences between bug, defect, error, fault, and
failure in the below table.

Compariso Bug Defect Error Fault Failure

n basis
Definition It is an The Defect is An Error is a The Fault is a If the software
informal name the difference mistake made state that has lots of
specified to between the in the code; causes the defects, it
the defect. actual that's why we software to fail leads to failure
outcomes and cannot to accomplish or causes
expected execute or its essential failure.
outputs. compile code. function.

Raised by The Test The Testers The Human The failure

Engineers identify the Developers mistakes finds by the
submit the defect. And it and cause fault. manual test
bug. was also solved automation engineer
by the test through the
developer in the engineers development
development raise the cycle.
phase or stage. error.

Different Different type Different type Different type Different type -----
types of bugs are as of Defects are of Error is as of Fault are as
follows: as follows: below: follows:
Based on
○ Logic priority: ○ Syntact ○ Business
bugs ic Error Logic
○ Algorith ○ High ○ User Faults
mic ○ Medium interfac ○ Function
bugs ○ Low e error al and
○ Resourc ○ Flow Logical
e bugs control Faults
And based on
the severity: error ○ Faulty
○ Error GUI
○ Critical handlin ○ Performa
g error nce
○ Major
○ Calcula Faults
○ Minor
tion ○ Security
○ Trivial error Faults
○ Hardwa ○ Software
re error /
○ Testing hardwar
Error e fault
Reasons Following are The below The reasons The reasons Following are
behind reasons which reason leads to for having an behind the some of the
may cause the the defects: error are as fault are as most important
bugs: Giving incorrect follows: follows: reasons behind
Missing coding and wrong Errors in the A Fault may the failure:
Wrong coding inputs. code. occur by an Environmental
Extra coding Dilemmas and The Mistake improper step condition
errors in the of some in the initial System usage
outside values. stage, process, Users
behavior and If a developer or data Human error
inside structure is unable to definition.
and design. compile or Inconsistency
An error in run a or issue in the
coding or logic program program.
affects the successfully. An irregularity
software and Confusions or loophole in
causes it to and issues in the software
breakdown or programming. that leads the
the failure. Invalid login, software to
loop, and perform
syntax. improperly.
Inconsistency
between
actual and
expected
outcomes.
Blunders in
design or
requirement
actions.
Misperception
in
understanding
the
requirements
of the
application.

Way to Following are With the help of Below are The fault can The way to
prevent the way to the following, ways to be prevented prevent
the stop the bugs: we can prevent prevent the with the help of failure are as
reasons Test-driven the Defects: Errors: the following: follows:
development. Implementing Enhance the Peer review. Confirm re-
Offer several software Assess the testing.
programming innovative quality with functional Review the
language programming system review necessities of requirements
support. methods. and the software. and revisit the
Adjusting, Use of primary programming. Execute the specifications.
advanced, and and correct Detect the detailed code Implement
operative software issues and analysis. current
development development prepare a Verify the protective
procedures. techniques. suitable correctness of techniques.
Evaluating the Peer review mitigation software design Categorize and
code It is executing plan. and evaluate errors
systematically. consistent code Validate the programming. and issues.
reviews to fixes and
evaluate its verify their
quality and quality and
correctness. precision.
5. Defect Rate and reliability, defect prevention,reduction
containment :

Software Reliability : Introduction

● Software Reliability can be defined as the ability of a software product to
perform consistently and be trustworthy to its users i.e. The software
product must perform as required and should not deviate from its goal.
● Reliability means trustworthy or consistent.
● Reliability of a software product is an important aspect as it shows the
actual ability of the software product.

Software Reliability : Software Metrics

● Software metrics are the standards of measurement for a software product
for certain properties and functionalities. Software metrics can be broadly
classified into three categories. These are listed below :

Software Metrics : Software Reliability

1. Process Metrics
○ The Process Metric are used for the improvement of the development
and maintenance of a software product. It mainly measures the
efficiency of the software product.
2. Product Metrics
○ The Product Metric are used for demonstrating the software product
characteristics and features such as the performance and its quality.
3. Project Metrics
○ The Project Metrics are used for demonstrating the characteristics of
whole software project which includes the total time, total cost,
productivity and teams.

Software Reliability : Defect Rate

● Defect Rate can be defined as the number of defect detected per unit the
number of test cycles.
 Defect Rate = (No of Defects Detected* 100) / (No of Test Cycles)

Software Reliability : Defect Density

● Defect density is defined as the number of defects arrived during a specific
period of time per unit the size of software/module.

Defect Density = (Defect Count) / (Size of module or software)

● The defect density is counted per thousand lines of code and is called as
KLOC.
● The standard for defect density is not fixed. But, one defect per thousand
lines of code is considered as good quality of the project.

Software Reliability : Defect Prevention

● Defect Prevention is a plan made out to reduce the number of defects in a
software product by identifying the cause of defect and preventing them to
cause other problems in the software.
● The strategy of defect prevention is to analyse the phases of the software
product where the defects were arrived previously and preventing the
occurrence of those defects in future.
● Defect Prevention causes an increase in productivity and effort reduction.

Software Reliability : Defect Containment

● It is a strategy, an attempt to increase the software quality and reducing the
cost of the software product simultaneously.
● Defect containment is reported usually as a percentage of defects captured
in the phase in which they are originated.
● Also, it is a process of displaying the information about the issues and
problems occurred and reported for a software system.

Software Reliability : Inspection in Software Quality

● Inspection in software project often leads to verification of quality of that
software product.
● With a goal of identifying the defects, Inspection refers to peers review of a
software product done by individuals in order to look for defects using
certain well defined processes.
● The stages of inspection of software quality includes:
1. Planning.
2. Overview Meetings.
3. Preparation.
4. Inspection Meeting.
5. Follow Up.
6. Rework.

6. Overview of Different types of software review:

Software Reviews : Introduction

 ● Software Reviews is a process of assessing a software product either in a
formal manner or in an informal manner. The software review can include or
can be done in the presence of customers, users, managers etc.
● Software reviews are generally categorized into three:

Software Reviews

Software Reviews : Software Peer Reviews

● Code Review: A code review is a process of analyzing the computer source
code for defects.
● Pair Programming: An inspection is an advanced form of code review in
which a pair of programmers develops code for a software product on same
work system.
● Inspection: An inspection is the most formal type of software peer review in
which defects are found using well defined processes.
● Walk-through: A walk-through a form of peer review in which the leader
demonstrates the work of the software product and the participants are
asked to comment on the defects.
● Technical Review: A technical review is a peer review in which the software
product is checked for its functionality by a team of professionals for its use
and identifies any vulnerabilities.

Software Reviews : Software Management Review

● The management study of a software project about its resource allocation is
called as software management review.
● The software management reviews are carried out by the management of
the governing body of that software project.
● Also, the goal of software management reviews is to identify the consistency
and deviation of software project from its original path.

Software Reviews : Software Audit Review

● A Software audit is a process of scrutiny a software product for its
functionalities and specifications.
● A software audit review is a type of software review in which auditing of
software product is done by members other than the development team.
● The goal of software audit review is to assess the specification and
compliance of a software product.
UNIT – 2
UNIT- 4