Browse Books

Reviewer: Watts Humphrey

This book is primarily a collection of the authors' previously published papers. Several of these include perspectives that could be useful to most software practitioners, and four of the chapters (3, 5, 10, and 17) contain material that IBM has agreed to release for the first time. The book's strength is the many perceptive comments on and insights into the large-scale software development and maintenance processes. The authors' ideas are stimulating and will prove particularly useful if they lead to a broader discussion of these subjects. Because of the historical approach, however, much of the material is repeated in several chapters. In addition, the authors' laws of software evolution are at least partially misleading. The book's thesis consists of three basic themes. The first concerns program evolution. The authors contend that large-scale complex programs must evolve. This is because the programs' requirements cannot be fully known until there has been some experience in using them, and then they must evolve in concert with the user's improving knowledge and experience. Change is thus perpetual with such programs. Second is the view that the software process is largely driven by the state of the software itself: changes are continuous, changes cause disorder unless they are directly countered, and a growth-saturation phenomenon limits the quality and productivity of the software development process. The third theme concerns the nature and consequences of the software maintenance process. This is a form of perpetual software change that can lead to serious management and software control problems unless these issues are understood and addressed. The authors' comments on the software maintenance process and the forces for disorganization in large systems are particularly perceptive. To an increasing extent, large software is currently built in stages. This is both because it is impractical to build such massive constructions in one step, and because evolution has been found far more manageable. The authors have performed a useful service by pointing out that the benefits of evolution carry risks that can be expensive if ignored. The authors also introduce the concept of natural limits to the software development process. They propose a saturation phenomenon that appears when these natural limits in resources, volume of change, or growth rates are exceeded. The justification for this view is not convincing and, in one case, is incorrect. For example, they state that there is a limit to the rate of incremental enhancement that can be made to a program and when this limit is exceeded, some corrective process is required. This is based on their observation that at IBM, whenever a particularly large OS/360 release was made, the system was subsequently split. While this is a correct description of the events, the authors have confused cause and effect. When IBM split the 360/370 operating systems, the plan was known well in advance, and this knowledge caused the previous release to be larger than normal. It grew because it became a catchall to incorporate last minute function just before the split and subsequent termination of system enhancement. The fundamental flaw of the book is its redundancy. For example, the important concept of entropy is repeated almost verbatim in six of the chapters. While this is only one case of the book's redundancy, it demonstrates how much of the reader's time is lost in wading through repetitive material. The generally poor quality of the book's production is also a distraction. The transition from an attractive typeface in the Preface to typewriter quality in the body of the text is obvious, and there are an excessive number of typographical errors and misspellings. The Preface and the Introduction provide a useful backdrop for the book and place it both in the proper historical and large systems context. The claim in the Introduction that this is the beginning of a new systematic approach to the software process, however, is not justified. Chapter 4 by Jerry Weinberg is wonderfully thought provoking. He adapts the Darwinian concept of survival of the fittest to software. While his proposed adaptive process has not been generally observed with large-scale general-purpose hardware, it seems increasingly plausible when applied to the large firmware and software systems that are now appearing. Chapters 5 and 13 present many perceptive ideas and concepts on the little understood subject of software maintenance. These are both worth a careful reading. Chapter 19 reviews the essential material on classes of programs and the laws of software evolution and should be read thoroughly. Chapters 20 and 21 build on these basic themes; while there is some minor duplication, the included discussion of environments and society's need to improve the software process is worth the reader's attention. While this book does not present as fundamental an argument as the authors suggest, it contains a number of important ideas. The software process is a complex subject that involves the interaction between human discipline and enormous logical constructs. Much remains to be learned about this crucial topic, and the authors' efforts deserve attention. While their work is closer to alchemy than science, this is necessarily the case at this time. One hopes that these early efforts will be followed by progressively more disciplined treatments.

Reviewer: Barry Boehm

Although program evolution (also called software maintenance or post-development software support) typically consumes 70 percent of software life-cycle expenditures, it has generally been relegated to secondary status in software organizations. Unfortunately, this underemphasis on program evolution has characterized not only software process management but also the academic study of the software process. The particular importance of Program evolution is, therefore, that it brings together a body of work on this underemphasized topic from two of its earliest students, Lehman and Belady. I would say that the main contributions of the book lie in three areas: :9BThe analysis of OS/360 and related program evolution data. The formulation of a set of “laws of program evolution.” General perspectives on the software process and its relation to processes in other fields. The OS/360 data, most thoroughly described in Chapter 3, are extremely impressive in showing both the large magnitude of system growth over time (from 1,152 modules and 400,000 source statements in release 1 in March 1966 to 3,819 modules and 1,740,000 source statements in release 16 in September 1968), and the inevitability of growth in the fraction of modules handled from one release to the next (from an average of 15 percent in releases 2–6 to an average of 32 percent in releases 12–16, and eventually to over 50 percent). This analysis alerted many people to the magnitude of software evolution activities, and to the likelihood that they could be significantly improved via better technical and management decisions. The five laws of program evolution are best explained and connected to the observational data from OS/360 and other projects in Chapter 19. The five laws are briefly summarized as follows: (1)A program that is used . . . undergoes continual change or becomes progressively less useful. (2)The complexity of an evolving program increases unless work is done to maintain or reduce it. (3)Program evolution is subject to a self-regulating dynamic yielding statistically determinable trends and invariances. (4)The global activity rate associated with an active program is statistically invariant. (5)The release content of successive releases of an active program is statistically invariant. Calling these statements “laws” is a bit ambitious. It is relatively easy to find counterexamples to them: for example, laws 3, 4, and 5 are not satisfied in software products that irregularly undergo major one-shot enhancements (e.g., a tax processing program in response to changes in tax laws). Further, the statistical basis of the laws is weak (except for law 1), as was found in the most significant attempt to date to independently validate them [1]. Yet they remain quite valuable as pervasive characteristics of the program evolution process and as general guidelines for managing program evolution, as illustrated in the case study in Chapter 19. Chapters 2, 3, and 19 have particularly useful perspectives on the software process, including some good insights on software life-cycle phases and their relation to different types of software products. Chapters 4 and 7 have some stimulating comparisons between program evolution, natural selection, and “limits to growth” hypotheses in other fields. The book has the usual problems associated with a collection of an author's papers. It is highly redundant: the OS/360 data are shown in six places, and the versions of the laws of evolution are discussed in five places. It contains a number of preliminary models that are not followed up in later chapters. It also operates at a high level of abstraction. One wishes for more concrete examples and how-to information. (Readers looking for such information can consult [2,3,4].) Recently, there has been mounting evidence that large software organizations are taking post-development software evolution much more seriously. This book can provide them with useful perspectives on the program evolution process and how to improve it.