Review By: Harmon Avera, Jr.
05/03/2002This is a software engineering textbook, aimed at “undergraduate students of computing or ‘crossover’ engineers” from another technical field. It focuses on the technical skills that an individual software engineer should have in “requirement analysis, design, coding, and testing.” As such, it serves as an initial textbook on software engineering. It’s easy to read, flows well, and covers the basic areas of requirements, design, code, and test.

The book presents software development in the standard waterfall model (with some caveats about this model’s relation to real life) and is divided into major sections that follow this development process. There are initial overview chapters that discuss concepts and principles of software development, management and process, and the software lifecycle. There is also an entire chapter devoted to the overall test plan. These chapters are followed by

– Requirements and Specification—exploring requirements, properties of good requirements, specification, and formal methods (i.e., First Order Predicate Logic);
– Design and Coding—software design, coding, pseudocode, finite state machines, abstract data types, object oriented design, data flow diagrams, and wrapping up design and coding;
– Testing—software testing, coverage (“systematic” testing), and the future of testing.

Each chapter has a summary (“How does it fit?”), review questions, ideas for further reading, and a list of references. There is an “Answers and Hints for Selected Exercises” section followed by an Index at the end of the book.

It was good to see the test plan concept introduced early and frequently referenced in an introductory software engineering textbook. Other software engineering themes in the book include

1. Divide complex problems to gain intellectual control;
2. Software development brings fuzzy, abstract ideas into the sharp focus of detailed design and working lines of code;
3. Record worries and test ideas when they occur, document assumptions, provide traceability back to requirements, and organize documents;
4. Avoid “Creeping Featuritis” and fixing systems that aren’t broken;
5. Change happens—plan for it and don’t procrastinate making required changes; and
6. “Always steal code, but don’t steal the wrong code and don’t steal code that doesn’t work.”

Although the authors mention that testing often takes 40 percent of the total development time, there are only three chapters actually devoted to software testing. They briefly cover

1. Basic testing concepts—unit, subsystem, and system-level testing, a brief discussion of code inspections, and test management;
2. Test Coverage—statement, branch, and path; tools; dataflow and mutation coverage; and
3. Random testing, automated testing, regression testing, and a brief discussion of current software testing “state of the art.”

This is not a book primarily about software testing (except as a part of the development process). This book can be useful to explain programming best practices to testers who have never developed software before. But there isn’t much new for a veteran programmer or tester.