Browse Books

Reviewer: Jeffrey B. Putnam

Classic descriptions of algorithms usually involve mathematical analysis and give us big-O-style results, but this may or may not tell us much about how the algorithms perform in actual use. The data involved may be small enough that the limiting cases never kick in, or the algorithm may be applied to data that has properties that work unusually poorly or unusually well (sorting algorithms often have very different performance characteristics for data that is almost sorted versus data that is random). Thus, performing experiments to test the behavior of an algorithm is almost always a good idea. This is true whether or not an analysis is present (to verify the math, to explore behavior for specific kinds of data, or to determine the behavior for small values of N ). In the latter case, experiments might help guide such mathematical analysis. Experimental analysis can also help incrementally improve an algorithm. This book provides guidelines and suggestions for performing experimental algorithmic analysis. It contains many examples and includes links to a companion Web site with code for some specific experiments (http://www.cs.amherst.edu/alglab/). The book is divided into seven chapters: (1) "Introduction"-what the book is about and how to use it. (2) "A Plan of Attack"-what an experiment is, what it intends to find out, and how to design experiments. (3) "What to Measure"-Is the time performance the most important part, or is the goodness of the result the goal (especially in heuristic algorithms)__ __ (4) "Tuning Algorithms, Tuning Code"-some hints on reducing the amount of work done and managing the tuning process. (5) "The Toolbox"-pointers to some online toolboxes and algorithm-related Web repositories, and how to generate random input as needed (a notoriously tricky process). (6) "Creating Analysis-Friendly Data"-how to reduce variance in output and simulation shortcuts (which can make it possible to do more experiments in the time allotted). (7) "Data Analysis"-brief coverage of useful statistics and graphical data presentation. The book seems mostly intended for those doing experimental algorithmics in academic settings. While practitioners can certainly learn a good deal from it, the examples may not be ideal for such readers. As such, it might serve as supplemental material in a graduate-level class, but might not suit undergraduates so well. Furthermore, some of the suggestions in chapter 6 might change the behavior of the algorithms sufficiently (by changing the way data or instructions are cached, or other factors) so that the analysis is no longer analyzing the behavior being studied but rather the added code. A few more examples aimed at the practitioner might have been nice. For instance, since sorting is familiar to all and most know the results of the formal analyses, a detailed discussion of a few sorting algorithms on different kinds of data (including the influence of hardware factors such as caches and branch prediction) would have been a useful early chapter. Running references to these examples would also have helped clarify some of the later chapters. The book is a good read with generally good examples, and is short enough to be easily digested. It is probably not long enough to use as a primary text in a graduate-level class, but a class primarily focused on mathematical tools for algorithmic analysis might find it useful. Online Computing Reviews Service