Software Design and Quality

Assurance
Lecture # 4
 What is Design? - 1
• Synonyms: plan, arrangement, lay out, map,
scheme
• Antonyms: accident, fluke, chance, guess
• Design is the backbone of all products and
services
• Considered an artistic and heuristic activity
 What is Design? - 2
• Design is a meaningful representation of
something that is to be built. It can be
traced to a customer’s requirements and at
the same time assessed for quality against a
set of pre-defined criteria of “good” design.
In the software engineering context, design
focuses on four major areas of concern:
data, architecture, interfaces, and
components
 An Important Point
• Try to associate quality attributes with
every aspect of software design
 Miracles of Software
Engineering
• “The most common miracles of software
engineering are the transitions from analysis
to design and design to code”
– Richard Due
• Many a times it actually takes a miracle for
these transitions to happen
• Whenever there is a transition, there is loss
(or possibly gain) of information
 Data Design
• The data design transforms the information
domain model created during analysis into
the data structures that will be required to
implement the software.
 Architectural Design
• It defines the relationship between major
structural elements of the software, the
“design patterns” that can be used to
achieve the requirements of a system, and
the constraints. Architectural design
representation is derived from system
specification, analysis model, and
interaction of subsystems.
 Interface Design
• Interface design describes how the software
communicates within itself, with systems
that interoperate with it, and with humans
who use it. An interface implies a flow of
information.
 Component Design
• Component-level design transforms
structural elements of software architecture
into a procedural description of software
components.
The Design Pyramid

Component-
level Design

Interface
Design

Architectural
Design

Data Design
 Design and Quality
• Design is the place where quality is
fostered(shown/visible) in software
engineering
• Design provides us with representation of
software which can be assessed for quality
• Design is the only way that we can accurately
translate a customer’s requirements into a
finished software product or system
 Without Software Design
• We risk building an unstable system
– one that will fail when small changes are made
– one that may be difficult to test
– one whose quality cannot be assessed until late
in the software process
– one that will be of no or very little use for
similar projects (not reusable)
 Design Process and Model
• Software design is both a process and a
model
• During the design process, the quality of the
evolving design is assessed with a series of
formal technical reviews or design
walkthroughs
 Design Process
• It is a sequence of steps that enables a
designer to describe all aspects of the
software to be built
• Needs creative skills, past experience, sense
of what makes “good” software, and an
overall commitment to quality
 Design Model
• Equivalent to an architect’s plan for a house
• Represents the totality of the thing to be
built
• Provides a variety of different views of the
computer software
 Design Defects - 1
• Defects introduced during preliminary
design phase are usually not discovered
until integration testing, which is too late in
most cases
• Defects introduced during detailed design
phase are usually discovered during unit
testing
 Design Defects - 2
• All four categories of defects (errors of
commission, errors of omission, errors of
clarity and ambiguity, and errors of speed
and capacity) are found in software design
and specification
• Most common defects are errors of
omission, followed by errors of commission
 Design Defects - 3
• Overall design ranks next to requirements
as a source of very troublesome and
expensive errors
• A combination of defect prevention and
defect removal is needed for dealing with
design defects
 Errors in Seven Fundamental
Design Topics - 1
• Functions performed
– Errors in descriptions of functions the
application will perform, are often errors of
omission
• Function installation, invocation, control,
and termination
– 50% of the problems reported to commercial
software vendors are of this class
 Errors in Seven Fundamental
Design Topics - 2
• Data elements
– Errors in data design
• Data relationships
• Structure of the application
– Complex software structures with
convoluted(complexed) control flow tend to
have higher error rates
– Prevention is often better than attempting to
simplify an already complex software structure
 Errors in Seven Fundamental
Design Topics - 3
• Sequences or concurrency of execution
– Many errors of speed and capacity have their
origin in failing to design for optimum
performance
– Performance errors are a result of complex
control flow, excessive branching, or too many
sequential processing (use parallel processing)
– Minimize I/O operations
 Errors in Seven Fundamental
Design Topics - 4
• Interfaces
– Chronic design problem(look & feel problem,
color combination problem, eye related
problem)
Errors in Eight Secondary Design
Topics
• Security
• Reliability
• Maintainability
• Performance
• Human Factors not creative or have experience, so
giving lame excuses
• Hardware Dependencies
• Software Dependencies
• Packaging
 How to Address Design
Problems?
• Continuously evaluate your design model
and design process
• Use defect prevention techniques like
design reviews, which have proven to be
the most valuable mechanism to improve
quality of software over the last thirty years
• Develop software design according to the
criteria presented
Design Evaluation Guidelines - 1
• The design must implement all of the explicit
requirements contained in the analysis model, and
it must accommodate all of the implicit
requirements desired by the customer
• The design must be readable and understandable
guide for those who generate code, write test
cases, and test the software
Design Evaluation Guidelines - 2
• The design should provide a complete
picture of the software, addressing the data,
functional, and behavioral domains from an
implementation perspective
 Guidelines for Good Design - 1
• A design should exhibit an architectural
structure that (1) has been created using
recognizable design patterns, (2) is
composed of components that exhibit good
design characteristics and (3) can be
implemented in an evolutionary fashion,
facilitating implementation and testing
 Guidelines for Good Design - 2
• A design should be modular; that is
software should be logically partitioned into
elements that perform specific functions
and sub-functions
• The design should contain distinct
representations of data, architecture,
interfaces, and components (modules)
 Guidelines for Good Design - 3
• A design should lead to data structures that
are appropriate for the objects to be
implemented and are drawn from
recognizable data patterns
• A design should lead to components that
exhibit independent functional
characteristics
 Guidelines for Good Design - 4
• A design should lead to interfaces that
reduce the complexity of connections
between modules and with external
environment
• A design should be derived using a
repeatable method that is driven by
information obtained during software
requirements analysis
 Design Principles - 1
• The design process should not suffer from “tunnel
vision” consider all factors
• The design should be traceable to the analysis
model
• The design should not reinvent the wheel some
difference from the previous model or version must
be included
• The design should “minimize the intellectual”
distance between the software and the problem as it
exists in the real world
 Design Principles - 2
• The design should exhibit
uniformity(standard) and integration
• The design should be structured to
accommodate change
• The design should be structured to degrade
gently, even when aberrant data, events, or
operating conditions are encountered
 Design Principles - 3
• Design is not coding, coding is not design
• The design should be assessed for quality as
it is being created, not after the fact
• The design should be reviewed to minimize
conceptual (semantic) errors
 Design Concepts - 1
• What criteria can be used to partition
software into individual components?
• How is function or data structure detail
separated from a conceptual representation
of software?
• What uniform criteria define the technical
quality of a software design?
 Abstraction
• As a designer, work hard to derive both
procedural and data abstractions that serve
the problem at hand, but that also can be
reused in other situations
• Abstraction is one of the fundamental ways
that we as humans cope with complexity
– Grady Booch
 Refinement
• There is a tendency to move immediately to
full detail, skipping the refinement steps.
This leads to errors and omissions and
makes the design much mode difficult to
review. Perform stepwise refinement
 Modularity
• Modularity is the single attribute of
software that allows a program to be
intellectually manageable
• Don’t over modularize. The simplicity of
each module will be overshadowed by the
complexity of integration
Effective Modularity Criteria for
Design Methods
• Modular decomposability
• Modular composability
• Modular understandability
• Modular continuity
• Modular protection
 Software Architecture
• The overall structure of the software and the
ways in which that structure provides
conceptual integrity for a system
 Information Hiding
• Modules should be specified and designed
so that information (procedures and data)
contained within a module is inaccessible to
other modules that have no need for such
information
 Cohesion
• Cohesion is the qualitative indication of the
degree to which a module focuses on just
one thing
• Highly cohesive modules are better
 Coupling
• Coupling is a qualitative indication of the
degree to which a module is connected to
other modules and to the outside world
• Loose coupling is better
 Other Design Concepts
• Control Hierarchy
• Structured Partitioning
• Data Structure
• Software Procedure
• Functional Independence
• Encapsulation
• Inheritance
• Polymorphism
 Design Methods
• Use a design method, which is most suitable
for the problem at hand. Don’t just use the
latest or the most popular design method
• There are many structured design and object-
oriented design methods to choose from
• Follow the design method’s representation
scheme. It helps in understanding design
 Software Design Tools
• Using software design tools improve
productivity
• Design tools also are useful for maintaining
data dictionaries, data relationships,
interface definitions, etc.
• Provide training in software design methods
and associated tools
 Conclusion
• We try to solve the problem by rushing through
the design process so that enough time will be left
at the end of the project to uncover errors that
were made because we rushed through the design
process
– Glenford Myers
• Design is the activity, if done right will
significantly improve the quality of software
product
 References
• Software Quality: Analysis and Guidelines
for Success by Capers Jones
• Software Engineering: A Practitioner’s
Approach by Roger Pressman
• Designing Distributed, Concurrent, Real-
Time Applications with UML by Hassan
Gomaa