Chapter 10

Software quality

This chapter discusses

Some important properties we want our system to have, specifically correctness and maintainability.

General design characteristic for achieving standards of quality.

External Qualities

External qualities are those with which the user is concerned.

Internal qualities are those that help achieve the external qualities.

One of the most obvious external qualities is correctness.

A system is correct if it conforms to its specifications.

Some attributes are quantitative, others are qualitative.

External Qualities (cont.)

Another important quality is efficiency.

memory requirements

system speed

For real-time systems, speed is a matter of correctness. If it doesn’t act in time, the system doesn’t act as expected.

User friendliness-- difficult to measure.

Robustness--no one wants a system to crash.

External Qualities (cont.)

Maintainability. How easily can the system be modified?

Maintenance activities:

Corrective: taken to correct errors in the system.

Adaptive: taken to adapt the system to changes in the environment or in the user’s requirements. Software that is adapted easily sometimes is called extendible.

Perfective: taken to improve the quality of the system.

Portability. Can the system run on different “platforms”?

External Qualities (cont.)

Compatibility. Can the system work with other software systems.

Complexity

Complexity is the principal obstacle to the creation of correct, reliable, maintainable software.

Software systems are inherently complex.

A good design can reduce complexity considerably.

Key: control the interactions between components.

Components should be self contained; interaction should be minimal and carefully defined.

Modularity

The logical components of the design should correspond to physically separate syntactic software components.

Modules should be self-contained and coherent.

Cohesion is a measure of the degree to which a module completely encapsulates a single notion (a facet of the system’s functionality or data).

Coupling is a measure of the degree to which a module interacts with and depends on other modules.

We want to design modules with high cohesion and weak coupling.

Reusable software modules

A library of standard pieces that can be used in commonly occurring situations.

Tailorable software components.

Principles

Information hiding principle: A module should be able to obtain information from another module only through a well-defined interface between them.

Continuity principle: A small change in the specifications should effect only a few modules in the system, and not the entire structure of the system.

Structuring a system around data rather than around functionality measurably enhances continuity.

Open-closed principle: The ability to modify or extend a module without affecting other modules.

A module that still can be modified is said to be open.

A module that is available for use by other modules is said to be closed.

Software = a temporary solution to an evolving problem

We must design a system that adequately models the problem as currently perceived, yet implement the system in such a way as to minimize dependency on the particularities of the problem at hand.

A temporary solution to an evolving problem

Object design produces the collection of objects that not only model the problem at hand, but also provide a set of fixed conceptual constituents in terms of which system evolution can be expressed.

Algorithm design involves providing the detailed functionality of the objects.

A temporary solution to an evolving problem (cont.)

As the system changes, we expect

the way the objects interact to change.

the set of objects defining the system to remain stable.

The quality of a model depends on how successfully the stable components are identified and isolated from the aspects of the problem likely to change.

Software = data + algorithms

Since every program handles data, attention must be paid to how the representation of the data can affect the algorithm.

Data is the fundamental and most stable aspect of a software system.

The design of an abstract view of the data, followed by the implementation of this abstract view by means of algorithms, is the essence of programming.

Software = English and mathematics

Software is executed by machines, but written and maintained by people.

A software solution must be read and understood by anyone intending to maintain it -- it should be clear and comprehensible to a human reader.

The correctness should be verifiable in a formal, mathematical sense.

Why is this important?

When testing a program to detect a possible bug, quality is directly related to our ability to:

read the code.

localize the affected code.

tractably modify the code.

We’ve covered

Correctness --Conforming to specifications

Maintainability--Modification with minimal difficulty.

Composing module that are:

highly cohesive.

weakly coupled.

Three design principles:

information hiding

continuity

open/closed

software as a temporary solution.

Software as data design followed by algorithm design.

Software as both an English document and mathematical document.

Slide 18

Slide 19


	Some important properties we want our system to have, specifically correctness and maintainability.
	General design characteristic for achieving standards of quality.


	External qualities are those with which the user is concerned.
	Internal qualities are those that help achieve the external qualities.
	One of the most obvious external qualities is correctness.
	A system is correct if it conforms to its specifications.
	Some attributes are quantitative, others are qualitative.


	Another important quality is efficiency.
		memory requirements
		system speed
	For real-time systems, speed is a matter of correctness. If it doesn’t act in time, the system doesn’t act as expected.
	User friendliness-- difficult to measure.
	Robustness--no one wants a system to crash.


	Maintainability. How easily can the system be modified?
	Maintenance activities:
		Corrective: taken to correct errors in the system.
		Adaptive: taken to adapt the system to changes in the environment or in the user’s requirements. Software that is adapted easily sometimes is called extendible.
		Perfective: taken to improve the quality of the system.
	Portability. Can the system run on different “platforms”?


	Compatibility. Can the system work with other software systems.


	Complexity is the principal obstacle to the creation of correct, reliable, maintainable software.
	Software systems are inherently complex.
	A good design can reduce complexity considerably.
	Key: control the interactions between components.
	Components should be self contained; interaction should be minimal and carefully defined.


	The logical components of the design should correspond to physically separate syntactic software components.
	Modules should be self-contained and coherent.
	Cohesion is a measure of the degree to which a module completely encapsulates a single notion (a facet of the system’s functionality or data).
	Coupling is a measure of the degree to which a module interacts with and depends on other modules.
	We want to design modules with high cohesion and weak coupling.


	A library of standard pieces that can be used in commonly occurring situations.
	Tailorable software components.


	Information hiding principle: A module should be able to obtain information from another module only through a well-defined interface between them.
	Continuity principle: A small change in the specifications should effect only a few modules in the system, and not the entire structure of the system.
		Structuring a system around data rather than around functionality measurably enhances continuity.
	Open-closed principle: The ability to modify or extend a module without affecting other modules.
		A module that still can be modified is said to be open.
		A module that is available for use by other modules is said to be closed.


	We must design a system that adequately models the problem as currently perceived, yet implement the system in such a way as to minimize dependency on the particularities of the problem at hand.


	Object design produces the collection of objects that not only model the problem at hand, but also provide a set of fixed conceptual constituents in terms of which system evolution can be expressed.
	Algorithm design involves providing the detailed functionality of the objects.


	As the system changes, we expect
		the way the objects interact to change.
		the set of objects defining the system to remain stable.
	The quality of a model depends on how successfully the stable components are identified and isolated from the aspects of the problem likely to change.


	Since every program handles data, attention must be paid to how the representation of the data can affect the algorithm.
	Data is the fundamental and most stable aspect of a software system.
	The design of an abstract view of the data, followed by the implementation of this abstract view by means of algorithms, is the essence of programming.


	Software is executed by machines, but written and maintained by people.
	A software solution must be read and understood by anyone intending to maintain it -- it should be clear and comprehensible to a human reader.
	The correctness should be verifiable in a formal, mathematical sense.


	When testing a program to detect a possible bug, quality is directly related to our ability to:
		read the code.
		localize the affected code.
		tractably modify the code.


	Correctness --Conforming to specifications
	Maintainability--Modification with minimal difficulty.
	Composing module that are:
		highly cohesive.
		weakly coupled.
	Three design principles:
		information hiding
		continuity
		open/closed
	software as a temporary solution.
	Software as data design followed by algorithm design.
	Software as both an English document and mathematical document.