I am of two minds about this book. First, it's essential reading for anyone who wishes to use the Differential Evolution (DE) algorithm in any serious way, or create their own implementation of it. But the book is not nearly as good as it should be for learning DE.
The nature of optimization is such that it will be of interest to a diverse group of people, such as:
1) People who need to use an existing implementation as-is to solve a problem, and need some guidance about the meaning of various adjustable parameters, and how to adjust them to achieve the best possible results.
2) People who need to solve a number of problems with DE, and may need to modify an existing implementation to do so.
3) People writing applications that use DE to solve one or more problems, and need to make sure the DE implementation in their own code "just works", so the application's users need not concern themselves with tweaking the optimizer.
4) People who wish to have a very deep knowledge of the subject, possibly creating new implementations of DE specific to their needs.
To accommodate the diverse needs of various readers, a more "top down" approach is needed. While the book does this to some extent, there is a haphazard structure to the book that needs improvement.
The book chapters are as follows, along with suggestions for improvement.
Chapter 1 is an introduction to optimization, discusses the nature of the optimization problem itself, the distinction between local and global optimization, and provides a brief introduction to DE. This chapter is done very well, providing just the right balance between mathematical description and appeal to intuition. As is done throughout the book, excellent illustrations are provided. It's a very good chapter not in need of modification.
Chapter 2 describes the details of the algorithm. Part way into this chapter is where problems arise. There are three main reasons for the difficulty. First, DE has a number of variants, and these aren't even spelled out clearly until the next chapter, in section 3.3.1. Second, concepts such as crossover are introduced by immediately spelling out details of the algorithm implementation without first explaining why we'd need or want to perform the crossover operation in the first place. Third, there are a number of categories of algorithm whose details are provided, yet some of these algorithms aren't even used by DE, although the distinction is not made clear. These categories include the following:
1) Algorithms common to all variants of DE
2) Algorithms used only for one specific variant of DE
3) Algorithms that aren't part of DE at all, but may be useful in some other context
4) Algorithms that aren't part of DE and should be avoided
In reading Chapter 2 I was often left wondering "Do I need to worry about this or not?" They need to move the general description of the algorithm variants from 3.3.1 forward into chapter 2, before the details of the algorithms are discussed. Any algorithm descriptions that are for something other than DE should only be done after the discussion of DE algorithms. On the positive side, Chapter 2 does include excellent illustrations that really aid understanding.
Chapter 3, which deals with benchmarking, is misplaced. Chapter 4, which is given the odd name "Problem Domains", belongs after the algorithm description in Chapter 2. "Problem Domains" deals with how to make use of DE to solve certain categories of problems, such as parameter quantization and constraints. These issues are very common, extremely important and must be figured out before one can do benchmarking. That said, Chapter 3 is fine as-is, but needs to be moved to a point in the book after that for which the solutions to most common problems are provided.
Chapter 4 ("Problem Domains") is well done too, but it might make sense to prioritize this chapter's discussion by first dealing with the problem types for which DE excels, while leaving other type of problems until later.
Chapter 5 on Architectural Aspects and Computing Environments is also well written and clear, dealing with such issues as parallel processors and systems with limited resources.
Chapter 6 discusses the source code of the algorithm. I found having this chapter open when studying the C source code helped my understanding of the code a lot. The code itself, however, is not really suitable for production purposes, but is pretty good for learning the details of the algorithm. Although the authors speak of the alleged benefits of the so-called "Hungarian notation", this notation is becoming passe, even to the extent that one of its former advocates, Charles Petzold of Microsoft, now discourages its use. Do a web search of "Hungarian notation sucks" to find his blog entry on the subject. The types of errors this notation is alleged to prevent can be prevented much better in practice by compiling with the highest warning level and ensuring that no warnings show up.
Chapter 7 discusses specific problems that have used DE for their solution. Understanding some of them requires domain knowledge that I don't have, but I was delighted to find that one of the authors, Rainer Storn, uses DE in his FIWIZ software to design digital filters having non-traditional design requirements. This is exactly the problem I am using DE for, so I was quite glad to see that section of the chapter. This is a good chapter.
To sum up, the individual chapters, with the exception of Chapter 2, are generally well-done, but the organization needs improvement. This haphazard organization may be due to the book having multiple authors, resulting in a lack of a clear vision for the book as a whole. After finishing the book, I was still confused about a number of issues, and these weren't cleared up until I read the book on DE by Feoktistov.