|
Advanced
We recommend that Maintainability Index Technique for Measuring Program Maintainability be read concurrently with this technology description. It illustrates a specific application of Halstead complexity to quantify the maintainability of software.
Halstead complexity measurement was developed to measure a program module's
complexity directly from source code, with
emphasis on
computational complexity. The measures were developed by the late
Maurice Halstead as a means of determining a quantitative measure of
complexity directly from the operators and operands in the module
[Halstead 77]. Among the earliest software metrics,
they are strong indicators of
code complexity. Because they are applied to
code, they are most often used as a
maintenance metric. There are widely
differing opinions on the worth of Halstead measures, ranging from
"convoluted... [and] unreliable"
[Jones
94] to "among the strongest measures of maintainability"
[Oman 91]. The material in this technology description is largely based on the empirical evidence found in the Maintainability Index work, but there is evidence that Halstead measures are also useful during development, to assess code quality in computationally-dense applications.
The Halstead measures are based on four scalar numbers derived directly from a program's source code:
|
n1
|
=
|
the number of distinct operators
|
|
n2
|
=
|
the number of distinct operands
|
|
N1
|
=
|
the total number of operators
|
|
N2
|
=
|
the total number of operands
|
From these numbers, five measures are derived:
|
Measure
|
Symbol
|
Formula
|
|
Program length
|
N
|
N= N1 + N2
|
|
Program vocabulary
|
n
|
n= n1 + n2
|
|
Volume
|
V
|
V= N * (LOG2 n)
|
|
Difficulty
|
D
|
D= (n1/2) * (N2/n2)
|
|
Effort
|
E
|
E= D * V
|
These measures are simple to calculate once the rules for identifying
operators and operands have been determined (Szulewski notes that establishing
these rules can be quite difficult
[Szulewski 84]). The extraction of the component
numbers from code requires a language-sensitive scanner, which is a reasonably
simple program for most languages. Oman describes a tool for use in
determining maintainability which, for Pascal and C, computes the following
[Oman 91]:
V for each module; and
V(g), the average Halstead volume per module for a system
of programs
For Pascal alone, the following are also computed:
E for each module; and
E(g), the average Halstead volume per module for a system
of programs
Applicability. The Halstead measures are applicable to
operational systems and to development efforts once the code has been
written. Because maintainability should be a concern during development, the
Halstead measures should be considered for use during code development to
follow complexity trends. A significant complexity measure increase during
testing may be the sign of a brittle or high-risk module. Halstead measures
have been criticized for a variety of reasons, among them the claim that
they are a weak measure because they measure lexical and/or textual complexity
rather than the structural or logic flow complexity exemplified by Cyclomatic Complexity measures
. However, they have been shown to be a very strong component of the
Maintainability Index measurement of maintainability (see Maintainability Index Technique for Measuring Program
Maintainability). In particular, the complexity of code with a high ratio
of calculational logic to branch logic may be more accurately assessed by
Halstead measures than by Cyclomatic Complexity, which measures structural complexity.
Relation to other complexity measures. Marciniak describes
all of the commonly-known software complexity measures and puts them in a
common framework
[Marciniak 94]. This is helpful background for any complexity
measurement effort. Most measurement programs benefit from using several
measures, at least initially; discarding those that do not suit the specific
environment; and combining those that work (see Complementary
Technologies). This is illustrated by Maintainability Index Technique for Measuring Program Maintainability, which describes the use of Halstead measures in combination with other complexity measures. When used in this context, the problems with establishing rules for identifying the elements to be counted are eliminated.
Halstead measures were introduced in 1977 and have been used and experimented with extensively since that time. They are one of the oldest measures of program complexity. Because of the criticisms mentioned above, they have seen limited use. However, their properties are well-known and, in the context explained in Usage Considerations, they can be quite useful.
The algorithms are free; the tool described in Technical Detail, contains
Halstead scanners for Pascal and C, and some commercially-available CASE
toolsets include the Halstead measures as part of their metric set. For
languages not supported, standalone scanners can probably be written
inexpensively, and the results can be exported to a spreadsheet or database to
do the calculations and store the results for use as metrics. It should be
noted that difficulties sometimes arise in uniquely identifying operators and
operands. Consistency is important. Szulewski discusses this, defines
consistent counting techniques for Ada, and points to other sources of
counting techniques for some other languages
[Szulewski 84]. Adding Halstead measures to an existing maintenance environment's metrics collection effort and then applying them to the software maintenance process will require not only the code scanner, but a collection system that feeds the resulting data to the metrics effort. Halstead measures may not be sufficient by themselves as software metrics (see Complementary Technologies).
Common practice today is to combine measures to suit the specific program
environment. Most measures are amenable for use in combination with others
(although some overlap). Thus, many alternative measures are to some degree
complementary. Oman presents a very comprehensive list of code metrics that
are found in maintainability analysis work, and orders them by degree of
influence on the maintainability measure being developed in that effort
[Oman 94]. Some examples are (all are averages across the set of programs being measured)
- lines of code per module
- lines of comments per module
- variable span per module
- lines of data declarations per module
Cyclomatic Complexity and its
associated complexity measures measure the structural complexity of a
program. Maintainability Index Technique for Measuring Program Maintainability, combines cyclomatic complexity with Halstead measures to produce a practical measure of maintainability.
Function point measures (see Function Point
Analysis) provide a measure of functionality, with some significant
limitations (at least in the basic function point enumeration method); the
variant called
engineering function points adds measurement of mathematical functionality that may complement Halstead measures.
Lines-of-code (LOC) metrics offer a gross measure of code, but do not measure content well. However, LOC in combination with Halstead measures may help relate program size to functionality.
This technology is classified under the following categories. Select a
category for a list of related topics.
|
[Halstead 77]
|
Halstead, Maurice H. Elements of Software Science, Operating, and
Programming Systems Series Volume 7. New York, NY: Elsevier,
1977.
|
|
[Jones 94]
|
Jones, Capers. "Software Metrics: Good, Bad, and Missing." Computer 27, 9
(September 1994): 98-100.
|
|
[Marciniak 94]
|
Marciniak, John J., ed. Encyclopedia of Software Engineering,
131-165. New York, NY: John Wiley & Sons, 1994.
|
|
[Oman 91]
|
Oman, P. HP-MAS: A Tool for Software Maintainability, Software
Engineering (#91-08-TR). Moscow, ID: Test Laboratory, University of
Idaho, 1991.
|
|
[Oman 94]
|
Oman, P. & Hagemeister, J. "Constructing and Testing of Polynomials
Predicting Software Maintainability." Journal of Systems and Software 24,
3 (March 1994): 251-266.
|
|
[Szulewski 84]
|
Szulewski, Paul, et al. Automating Software Design Metrics
(RADC-TR-84-27). Rome, NY: Rome Air Development Center, 1984.
|
Edmond VanDoren, Kaman Sciences, Colorado Springs
10 Jan 97 (original)
The Software
Engineering Institute (SEI) is a federally funded research and
development center sponsored by the U.S. Department of Defense
and operated by Carnegie Mellon University.
Copyright
2008
by Carnegie Mellon University
Terms of Use
URL: http://www.sei.cmu.edu/str/descriptions/halstead_body.html
Last Modified: 24 July 2008
|
