| The truth is, everyone has had trouble
with software development. The sad truth behind this first truth is that we, as
individuals, as managers, as organizations, have had trouble facing up to this
truth. In recent years, however, many organizations are overcoming these troubles.
Others are not yet so successful. Successful organizations have found that it
is the intelligence behind successful software management that makes the difference.
The first step toward identifying that intelligence rests on the effective application
of simple metrics to manage software development.
The
Five Great Truths About Metrics
1 There must
be an accurate way to represent in metric terms what goes on in software
development: - Establish a measure of functionality beforehand.
- Establish
a measure of the productivity of your software process.
- From this functionality,
given this productivity, estimate time, effort, and defect rate.
The
feature that distinguishes the accurate way from other ways is the realization
that time and effort are multiplicatively intertwined; they are interdependent;
they cannot, with accuracy, be planned independently of each other. Every estimate
is a time-effort pair, an effort with an associated time. 2
We need this accurate way to underpin estimating, bidding, project control, and
the relations between client and developer or client and outsourcer. 3
We need this accurate way, not only for these business reasons, but because it
is the only way to provide development people in appropriate numbers (effort)
with enough time (schedule) to do the work at the quality and reliability levels
needed by the client's application. 4 We need this
accurate way to provide a satisfactory working situation. The accurate way is
the only way to keep staff around long enough to grow a superior organization.
5 We need this accurate way to measure a software
organization's competitive standing. This measure—process productivity—tells
management and staff not only that they are on the right track for improving their
organization, but also that they can endure for the substantial time it takes
to grow a superior organization.
The Five Great Truths
About Software Development
Metric truths are of great importance,
but their further consequence is to make possible the realization of the five
great truths about the field of software development as a whole. 1
There must be an activity to which to apply the five core metrics. That
activity is the process. A software organization must have a way of doing
its work. That way may be informal or it may be as concrete as the Unified Process.
At the very least, it has to be repeatable, if estimates of time, effort, and
process productivity are to have any meaning. 2
There must be some standards, and there have been—a lot of them, from
programming languages to text editors. In recent years, the standards idea has
moved on to the Unified Process and the Unified Modeling Language. 3
There must be reuse of previously developed software to reduce the effort
and time needed to develop the new product. There is considerable reuse already,
under the general name component-based development. The preexistence of process
and standards is a prerequisite to more extensive reuse. 4
There must be software tools to take over the routine tasks of software
development. For example, there is no reason to make a developer hand-draw the
rectangles, ovals, lines, arrowheads, and other features of UML when he or she
can command a software tool to do so. Note, however, that first the modeling features
have to be standardized before developing and marketing the tool becomes economical.
As Jacobson, Booch, and Rumbaugh have noted, "Successful development of process
automation (tools) cannot be achieved without the parallel development of the
process framework in which the tools are to function."[1] 5
There must be a means of bringing to the developer the procedural knowledge
he or she needs to accomplish the task immediately at hand. This need arises out
of the reality that the volume of knowledge applicable to software development
is now overwhelming, with one example alone amounting to more than 20,000 pages.
Mere humans need an automated tool to guide them to what they need when they need
it.
[1] Ivar Jacobson, Grady Booch, and James Rumbaugh, The Unified
Software Development Process (Reading, Mass." Addison-Wesley, 1999),
p. 29. | 
