The aim of software engineering is to produce software that is delivered on time and within budget, that satisfies all its requirements, and that can be maintained easily. The first lesson of this book is that maintenance is the most important activity in software development. Its first two chapters highlight the wide scope of this field and survey the book as a whole.

Part 2 is devoted to the software life cycle as a whole. Chapter 3 describes life cycle models, including the waterfall model and rapid prototyping, as well as some aspects that are not related to particular phases or models. The main theme of chapter 4 is the importance of planning and quality assurance. Typical examples are the IEEE Software Project Management Plan and the COCOMO model to estimate time and cost. The next chapter briefly considers the principle of stepwise refinement and demonstrates that this principle can help the software engineer to master complexity in every phase. The last chapter of this part is dedicated to the second lesson of the book: testing is not a phase, but must be carried out in parallel with all activities. Different phases need different test techniques; the author covers a variety of methods, including correctness proofs, walkthroughs, and test case selection, but he does not omit such issues as measuring the complexity of the product.

The main part of the book (chapters 7 through 11) describes the phases of the life cycle in depth and illustrates each phase by instructive case studies. In chapter 7, the author considers how to specify what the product has to do: informally, semiformally, or formally. He illustrates the differences by describing some methods, including structured analysis, Petri nets, and PAISley. The purpose of chapter 8 is to introduce some theoretical concepts regarding modularity. The author discusses the different levels of cohesion and coupling, as well as encapsulation and abstract data types. The next chapter goes into detail explaining some design methods: dataflow analysis represents process-oriented design, Jackson’s design method illustrates the data-oriented approach, and object-oriented design serves as an example of a hybrid method. Chapter 10 examines the problem of translating the design into code. Unfortunately, selecting a suitable programming language is discussed only briefly. (The author says that, in most cases, one has no choice; although he is right, instructors must point out as often as possible that the programmer should have a choice.) The chapter does contain a useful discussion of what structured programming really is. The issues of team organization and the use of tools round off this chapter. Chapter 11 presents some aspects of version and configuration control as well as managing the maintenance process. Its brevity contrasts with the author’s statement that maintenance is the most important phase.

Part 4 presents six topics relevant to the current and future practice of software engineering. Chapter 12 stresses the importance and scope of computer-aided software engineering. Schach compares different types of CASE tools and describes the ISTAR environment in some detail. Portability and reusability are examined in the next chapter. The barriers to portability as well as some techniques for promoting it are described. Some case studies may convince the reader that reusability is more than a theoretical principle. Chapter 14 analyzes the historical and political background of Ada and the interaction between this language and software engineering because Ada embodies many of the principles discussed in this book. The last two chapters sketch issues that will probably gain importance in software engineering. First, Schach stresses the need for experimentation and outlines some ways to organize software development experiments. Finally, he mentions the possibility of an automatic programming life cycle.

This well-structured book can be used as a classroom textbook. The exercises are divided into several groups. Some of the problems test insight into the material, while others require the student to solve a concrete example. A term project is broken into pieces that are distributed among the chapters. The last type of problem is based on reading original papers. The references are both assigned to the chapters and collected at the end of the book. An accompanying instructor’s manual contains some teaching suggestions and proposes solutions to the exercises. These solutions (and many examples in the textbook) are written in Ada, but they can be understood without previous experience with this language. Finally, the manual provides copies of all figures to assist in the preparation of transparencies.