Professional Documents
Culture Documents
Software Quality
Software Quality
Software Quality
UNIT-1
SOFTWARE QUALITY
Quality engineering (QE) is a process that applies rigorous quality checks to each stage of
product development. It does this through analysis, development, management, and maintenance
of quality assurance (QA) protocols. QA is often continued after a product has been delivered.
The goal of QE is to ensure the quality of a product from the beginning, minimizing potential
losses caused by defects.
Functionality: This attribute determines the conformity of a software-driven system with the
defined requirements and specifications.
Performance: It can be understood as the ability of a software-driven system to conform to
timing requirements.
Reliability: Reliability is to check if the application or the testing product with different
combinations to see if it withstands its nature and produces the expected result.
Testability: It indicates how well the application allows software testers to perform tests in line
with the predefined criteria.
Availability: It can be defined as a ratio of the system’s available time to the required time it is
expected to perform.
Interoperability: Interoperability is the ability of the system to interact with other systems to
exchange the required information via certain interfaces.
Security: security attribute measures the ability of a system to protect and block malicious or
unauthorized actions that could negatively impact the user or destroy the system.
Security also includes authorization and authentication techniques, protection against network
attacks, data encryption, and other risks.
Flexibility: the system should be flexible enough or should be able to modify accordingly.
Appraisal Costs:
Examples include inspection, testing, process or service audits, calibration of measuring and test
equipment.
Prevention Costs:
Activities planned and designed before operations to guarantee good quality and prevent bad
quality products or services.
Examples include new product review, quality planning, supplier surveys, process reviews,
quality improvement teams, education and training.
Expenses incurred to remedy defects discovered before the delivery of a product or service.
Examples include scrap, rework, re-inspection, re-testing, material review, material downgrades.
Examples include processing customer complaints, customer returns, warranty claims, product
recalls.
A failure is the inability of a software system or component to perform its required functions
within specified performance requirements. When a defect reaches the end customer it is called a
Failure. During development, Failures are usually observed by testers. When the faults in a
software product gets executed, they turns into Failures.
Fault: An incorrect step, process or data definition in a computer program that causes the
program to perform in an unintended or unanticipated manner. A fault is introduced into the
software as the result of an error. It is an anomaly in the software that may cause it to behave
incorrectly, and not according to its specification. It is the result of the error.
BUG:
A bug is the result of a coding error. An Error found in the development environment before the
product is shipped to the customer. When an error is found during the development phase
and is accepted by developers is called as Bug.
When the functionality of the software products gets changed i.e. mistake made while
coding are called as Errors. For example : Wrong syntax and infinite loops can cause
errors.
Defect: a Defect is a difference between expected and actual results in the context of testing.
It is the deviation of the customer requirement.
Software Reliability : Introduction
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 :
1. Process Metrics
o 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
o The Product Metric are used for demonstrating the software product
characteristics and features such as the performance and its quality.
3. Project Metrics
o The Project Metrics are used for demonstrating the characteristics of whole
software project which includes the total time, total cost, productivity and
teams.
Defect Rate
Defect Rate can be defined as the number of defect detected per unit the number of
test cycles.
Defect density is defined as the number of defects arrived during a specific period of
time per unit the size of software/module.
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.
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.
Reducing the defects to improve the quality: The analysis should lead to implementing
changes in processes that help prevent defects and ensure their early detection.
Applying local expertise: The people who really understand what went wrong are the
people present when the defects were inserted – members of the software engineering
team. They can give the best suggestions for how to avoid such defects in the future.
Targeting the systematic errors: There may be many errors or defects to be handled in
such an analysis forum; however, some mistakes tend to be repeated. These systematic
errors account for a large portion of the defects found in the typical software project.
Identifying and preventing systematic errors can have a big impact on quality (in terms of
defects) for a relatively small investment.
The first measure to reduce defect prevention is Education and training. Education provides
people with the right tools to detect error and avoid them. This training can be done at various
levels:
Product and domain specific level: People developing a product for a specific area should be
as familiar as possible with that area.
Software development expertise: This is probably the most intuitive of all. The objective is to
develop a software product, thus, expertise on development techniques are fundamental.
Knowledge about methodology, technology and tools: Using the right tools and methodology
have an impact on the quality of a product.
Development process knowledge: The development process should be understood in detail by
all team members. Misunderstanding in some of the procedures will sure increase the
possibility of errors occurring and deriving into failures.
Defect reduction is a task that aims at covering 100% of all possible behaviour, knowing that
reaching that mark is impossible. Thus, the strategy is to try to explore as much as possible of the
entire behaviour space and hope that most of the defects are detected. The difficulty of these
techniques is that to cover all aspects of a product, sometimes an equally complex testing
infrastructure is needed.
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.
Defect containment refers to the ability of a software product to detect a failure and
maintain its effect within some reasonable bounds that still allow the product to proceed.
The approach in this stage is different. Not all faults can be detected, thus, some
additional measures need to be put in place for when a failure occurs, to minimize its
impact. The techniques to contain the effect of a failure are usually referred also a s“fault
tolerance”.
Software 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.
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.
There is a number of metrics available based on which software quality is measured. But among
them, there are few most useful metrics which are most essential in software quality
measurement. They are –
1. Code Quality
2. Reliability
3. Performance
4. Usability
5. Correctness
6. Maintainability
7. Integrity
8. Security
Metrics:
A metric is a measurement of the level at which any impute belongs to a system product or
process.
Software metrics will be useful only if they are characterized effectively and validated so that
their worth is proven. There are 4 functions related to software metrics:
1. Planning
2. Organizing
3. Controlling
4. Improving
1. Quantitative: Metrics must possess quantitative nature. It means metrics can be expressed in
values.
2. Understandable: Metric computation should be easily understood, and the method of
computing metrics should be clearly defined.
3. Applicability: Metrics should be applicable in the initial phases of the development of the
software.
4. Repeatable: The metric values should be the same when measured repeatedly and consistent
in nature.
5. Economical: The computation of metrics should be economical.
6. Language Independent: Metrics should not depend on any programming language.