201 Principles of Software Development

From the Preface If software engineering is really an engineering discipline, it is the intelligent application of proven principles, techniques, languages, and tools to the cost-effective creation and maintenance of software that satisfies users' needs. This book is the first collection of software engineering principles ever written in one volume. A principle is a basic truth, rule, or assumption about software engineering that holds regardless of the technique, tool, or language selected. With few exceptions, the principles published here are not original. They have been extracted from the writings of many software engineering practitioners and researchers. These individuals have been unselfish enough to share their experiences, ideas, and wisdom with all of us. I make no claim that these 201 principles are mutually exclusive. Unlike Boehm's seven "basic" software engineering principles, a combination of some of these principles may imply another. I also make no claim that these 201 principles are 100 percent compatible. The adages, "Absence makes the heart grow fonder" and "Out of sight, out of mind" are each true, and each can be applied to life, but they cannot both be used to justify the same decision. The principles contained in this volume are all valid, and they can all be used to improve software engineering, but it may be impossible to apply some combinations of them on any one project. Manny Lehman [LEH80] has stated eloquently why principles underlying software engineering are inherently different from principles underlying other areas of human exploration. He states there is no reason to expect such principles to have the same "precision and predictability of [say] the laws of physics." The reason for this is that, unlike physics or biology, the process of software development is "managed and implemented by people; thus in the long term [its behavior should] be expected to be unpredictable, dependent on the judgments, whims, and actions of [people]." On the other hand, software does seem to exhibit many regular and predictable traits [LEH80]. These lead to many basic principles that can be enumerated and used by inexperienced and experienced software engineers and managers to enhance the quality of both the software engineering process and software products. The purpose of this book is to present in one volume the principles of software engineering as a reference guide. It is aimed at three classes of readers: 1. Software engineers and managers. In this book you can find out what is good and what is not. If you are new at software engineering or software management, here is a place to find out what you need to know. 2. Students of software engineering. For students, there are two primary uses of this book. First, here are the basic, nondogmatic tenets that every software engineer should know. Second, the references in these pages point to some of the best papers and books ever written on software engineering. If you do nothing other than read the items referenced, this book will have been successful, and you will have been exposed to a wealth of knowledge. 3. Software researchers. Researchers may often find it difficult to find the original source of an idea. I have provided references to publications that reflect either the original source or an alternative, excellent work that refers to the original source. I sincerely hope that everybody who buys this book attempts to read as many of the referenced works as possible. My brief description of the principle is intended to be friendly, easy-to-read, and insightful. But for real appreciation you need to read the referenced works. These works are not necessarily the original source of the idea (although in many cases they are). Nor is the given principle necessarily a primary point of the reference. In every case, however, the referenced work contains a wealth of helpful background, insight, justification, backup data, or information related to the principle. In summary, this book should be the first place for you to look up any software engineering idea. However, this is a book of principles, not techniques, languages, or tools. You will not find out how to use any techniques, languages, or tools which the principles described here transcend. Furthermore, this book tries to avoid all fads, good or bad! For the most part, fads are popular for three to ten years, then lose favor. The underlying principles that might be behind a fad can be found in this volume, but not the fad itself. Thus, for example, you won't see any reference to object-orientation per se here, but you will find many references to the principles underlying object-orientation, such as encapsulation. The principles are organized into general categories to aid in finding them and to aid in relating similar principles. These categories correspond to primary phases of software development (that is, requirements, design, etc.) and to other critical "support" activities, such as management, product assurance, and so on, as shown in Fig. P-1. REFERENCES [BOE83] Boehm, B., "Seven Basic Principles of Software Engineering," Journal of Systems and Software, 3, 1 (March 1983), pp. 3-24. doi:10.1016/0164-1212(83)90003-1 [LEH80] Lehman, M., "On Understanding Laws, Evolution, and Conservation in the Large-Program Life Cycle," Journal of Systems and Software, 1, 3 (July 1980), pp. 213-221. doi:10.1016/0164-1212(79)90022-0 [ROY70] Royce, W., "Managing the Development of Large Software Systems," WESCON '70, 1970; reprinted in 9th International Conference on Software Engineering, Washington, D.C.: IEEE Computer Society Press, 1987, pp. 328-338.