Browse Books

Reviewer: Jeffrey B. Putnam

Programming would be easy if the program didn't have to work. But we all know that programming is tough, because programs do have to work. We also know that it can be difficult to determine what a program (or a component of a program) actually needs to do. It is just as difficult, often even more difficult, to ensure that the program actually does what is needed. Ensuring that programs do what we want them to do (or what we think we want them to do) is the domain of testing. Testing can be something of an art and requires specialized skills and tools. Performing testing well is at least as demanding as building the software in the first place. This book consists of 23 chapters-essentially, essays by experts in the field on the general topic of testing. They talk about not only why testing is essential and why it is hard, but also how they manage to do it and why they find it rewarding. Many of the essays are anecdotal, telling us how the author has solved this problem or that; some are more descriptive, talking about specific kinds of problems or testing frameworks. While most are quite readable and interesting, a couple of them do not quite work, and at least one reads like a thinly veiled advertisement. This is not the book to read to learn about how to use any particular test framework. The coverage is broad and aimed at software developers (and managers) interested in the value of testing as a discipline. As such, it covers everything from fault injection to fuzzing to unit testing, in enough detail to interest the reader; it also provides uniform resource locators (URLs) or other references that point to more information. Thus, the book provides a nice overview of the field, with enough information to convince readers that testing is difficult and a deeper problem than usually thought, but also that it is not out of the reach of most development teams. It also shows-with a generous helping of pointers to test both commercial and open-source products-that the right kind of information and software is available to help development teams work on improving their testing methodologies. The book should also prove useful to managers who are either managing test teams or are otherwise interested in software quality and would like to know about other ways to test and how others have solved related problems. This would be an excellent supplemental text for a course in software engineering, as several of the chapters present testing not just as a dry and dull process, but as an interesting and potentially exciting activity that could be well worth looking into as a career choice. The only major problem with the book is the large number of URLs presented in the text. Their presentation is inconsistent, sometimes in the form of footnotes and sometimes inline, in the text. In either case, they are not available in an easy-to-use format and there is no Web page with the URLs from the book presented chapter by chapter. This would be a nice supplement. Another-minor-problem is that many of the authors took the title to heart and seem intent on using the phrase "beautiful testing," telling the reader why their methods are indeed "beautiful." Perhaps they are, but, on about the fourth repetition, it feels just a bit forced. While it may not be considered a proper testing methodology, coverage of the methods used in the design by contract approach would be a nice addition, as-when done well-they complement testing methods in ways that span the design, implementation, testing, and even release stages of software, quite nicely. Online Computing Reviews Service