Notes from Fundamentals of Software Engineering (Ghezzi et al.

1991)
I. Types of Software Qualities
External Qualities In general, these are qualities that the user sees and cares about.
Ex. reliability and user friendliness
Internal Qualities These are qualities that concern the developer. They help the developer
achieve the external qualities.
Ex. Verifiability helps achieve reliability.

II. Qualities of the Software Process or Product

Correctness
Right result according to the spec. Spec. and software are equivalent. This means that the spec.
must not be ambiguous! Specs. written in natural language (such as a program description
written in English) are usually ambiguous. Code reuse (from standard libraries, rather than
inventing new ones) helps improve correctness. Using high level languages helps too. For
example, code written in assembly language is more likely to have errors than code written in
Java.

Reliability
Dependable. The probability of failure is low. Users expect a newly released product to be
buggy. But a new car or a new bridge is expected to be perfect. This is because of the
immaturity of the software engineering field. Civil and mechanical engineering are more mature
engineering disciplines.

Robustness
How well the product handles exceptional conditions such as hard disk crashes or wrong input
from user. The attention devoted to making a program robust depends on the programs purpose.
If the program is to be used by novice computer users, it should be prepared to deal with
incorrect inputs (letters where numbers are expected). If a programs input always comes from a
sensor, then incorrect input may not be an issue. If the program is to be used to control lifecritical devices, then extra robustness is needed.

Performance
Efficiency in terms of space or time. Does it run slowly, use up too much memory, or use too
much disk space. Is the algorithm scalable? This means, when the input size increases, can we
still use this algorithm - or will it be too slow?

User friendliness
Do people find it easy to use? Is the interface consistent? Can novices use the program easily?
Are there keyboard shortcuts for expert users?

Verifiability
Can the systems properties be verified? Commonly performance or correctness need to be
verified. In a high security system, the operating kernal may need to be verified.

Maintainability
Can the new team of computer programmers maintain this software? Maintenance costs exceed
60% of the total costs of software. Maintenance activities include correcting errors (bugs),
adapting the software to new hardware or new operating systems, and also adding functionality.

Reusability
Can we reuse software components in other software projects? There is a high degree of
reusability in other industries such as consumer electronics. Components in the automotive
industry are highly standardized to be reused. The software industry has a relatively low degree
of reusability.

Portability
Software is portable if it can run in different environments. The term "environment" refers to
operating systems as well as to hardware platforms.

Understandability
Can new software programmers quickly understand the interactions of the software components?
Is the design well thought out? Is the code well commented? Are the algorithms easy to follow or
very complicated? These are considerations from an internal view. From an external viewpoint,
the user thinks the software is understandable if it has predictable behavior.

Interoperability
This is the ability of a system to coexist and cooperate with other systems. For example, the
ability of a word processor program to take input from a graphing application and embed a chart
inside a text document. Interoperability is more common in other engineering products. For
example, even old stereo systems accommodate new technologies such as compact discs. But, an
old operating system would not be able to work with a new optical disk.

Productivity
This is a quality of the software production process. It measures the efficiency of the process. An
efficient process results in faster delivery of a software product.

Timeliness
Timeliness is another process quality. Can the product be delivered on time? Lack of timeliness
led to the birth of software engineering itself. Timeliness requires careful scheduling, accurate
work estimations, and clearly specified and verifiable milestones.

Visibility
A software development process is visible if all of its steps and its current state are documented
clearly. In many software projects, most engineers and even the managers are unaware of the
exact status of the project.

III. Software Eng. Principles

Rigor and formality
Software development is a creative activity. But structure is needed as well. Rigor means being
very thorough, paying attention to detail. Formality is the highest degree of rigor. Formality
requires the software process to be driven and evaluated by mathematical laws. Obviously
programming is an activity requiring both creativity and rigor. The software development
process also needs to be controlled rigorously.

Separation of concerns
Separation of concerns means to deal with different aspects of a problem separately. There are
several ways that concerns may be separated. First, you can separate them in time. Let's say that
a program must accomplish 4 things sequentially. You might separate the project into 4 pieces.
Another way to separate concerns is through qualities. Suppose that a software project must
possess the qualities of correctness and efficiency. You could first deal with the issue of
correctness and establish that the code is correct. Then you could restructure that code to
improve its efficiency.
Another way to separate concerns is with different views. One view of how a piece of software
works is to examine the flow of data from one component to another. Another view is to
concentrate on the flow of control that governs how different activities are synchronized. Both
views help us to understand the system, although neither one gives a complete picture of what is
going on by itself.
Lastly, we may decide to separate our concerns by parts. Dividing a complex system into
simpler pieces called modules. See below.

Modularity
Modular = composed of modules (simpler pieces)
Benefit of modularity: allows one to deal with details of each module in isolation and to ignore
details when looking at all modules and their relationships.
Goals of modularity:
Decomposability: divide and conquer: break into subproblems and tackle each part
separately.
Composability: starting bottom up from elementary components and composing the full
system. e.g., automobile manufacture.
Modules must have high cohesion and low coupling. (Section 9.2 of your text.)

cohesion - an internal property of a module

All the elements of a module must be related strongly. There should be good reasons that
they are all together in the same module.

coupling - a characteristic of the module's relationships to other modules

This is the measure of interdependence of 2 modules. If 2 modules depend on each other
heavily, they have high coupling. We would like modules to be more self contained (to
have low coupling).

High cohesion and low coupling means we can look at modules as black boxes in a big picture
view .. example of separation of concerns.

Abstraction
Abstraction is a process where we identify important aspects of a phenomenon and ignore its
details. This is a powerful technique for mastering complexity. Programming is full of
abstractions. We ignore the details of how numbers are represented as bits in the hardware. We
ignore the details of the machine language when we use higher level languages such as Java. We
use classes in Java and deal with the important behaviors of the class and ignore how the
individual methods work.

Anticipation of change
This is the ability of software to evolve. What causes software to change?
changed / updated requirements
user feedback
When software is written to be reusable, it is easier to adapt to change.

Generality
Generality: solve the problem behind the apparent problem! If you make your code more
general, perhaps you can reuse it in another project.
Generality could be costly: the general problem may be harder to solve (algorithm, speed of
execution, memory requirements, development time) than special case at hand.

Incrementality
Incrementality describes a process that proceeds in a stepwise fashion, in increments. The
desired goal is reached by successively closer approximations to it. One way of applying the
incrementality principle is to identify subsets of an application that may be developed and
delivered to customers to get early feedback.
We can also add performance incrementally. Many beginning programmers write too much
code before getting any of it to work. They do not follow the incrementality principle.