The authors present a truly concise summary of constraint-based logic programming. In publishing house marketing, concise is often a synonym for the author got bored half-way through writing the book and that is why it is less than one inch thick. That is definitely not the case here. Not only is the coverage of the material comprehensive, it is also obvious that the book went through many revision and pruning cycles by the authors.

Although not directly obvious from the title, the book focuses virtually exclusively on constraint programming in logic programming languages. Hence, a good starting point is the appendix, where the authors introduce first-order logic. With a very brief presentation of syntax, semantics, and calculi, this section gives the reader a preview of the basic pattern followed by the book: a definition, followed by an explanation, and then sometimes an example.

True to the concise mantra, the first three chapters, which provide a brief background and introduction, do so in less than seven pages. The next four chapters follow a similar pattern. Each starts with the language calculus, defining the syntax and operational semantics, then proceeds to a discussion of the declarative semantics, and ends with theorems for soundness and completeness. These four chapters present logic programming, constraint logic programming, concurrent constraint logic programming, and constraint handling rules.

Chapters 8 to 13 cover different constraint systems, with chapter 8 setting the groundwork for the following five. Chapter 8 identifies the basic properties of general constraint systems, and then proceeds to identify the capabilities and properties desired of constraint solvers. It ends with a few fundamental principles of constraint-solving algorithms.

The next five chapters cover Boolean, rational tree, linear polynomial equation, finite domain, and nonlinear equation constraint systems. In covering each type of constraint system, the authors present the applicable constraint-solving algorithm, and cover both local-propagation and variable elimination constraint solvers. Each chapter also has an application section, where the constraint solver is applied to a simple problem in that particular constraint system domain, stepping the reader through the solution sequence.

The final section of the book presents three commercial applications of constraint programming. The first is an application to identify the optimal placement of wireless networking transceivers, given a building plan to minimize the number of transceivers required. The second application is a rent estimation tool that provides solutions based on limited and potentially inaccurate input data. The final application is the application of constraint programming to university course timetabling.

Overall, the layout and presentation of the theory is excellent. The book is concise, yet comprehensive. My only complaint is its readability; all too often, the text reads like a journal paper.

The authors identify their work as a textbook for graduate students, and a resource for researchers and practitioners. In my opinion, this book is far too concise, and the examples also too simplistic for it to be of much use to practitioners. Having said that, I need to point out that the book is by far the best summarization of journal literature that I have come across.

As a graduate textbook, the books suitability is conditional. It does presume a significant background in logic programming and first-order logic. This knowledge would either have to be a prerequisite for taking the course, or the text would have to be supplemented with a book on first-order logic. A secondary influence would be the lecturing approach chosen. If you were to provide the basics in the lecture, and expect the student to gain depth and further exposure by reading the text, then this book would be lacking. If your style is to provide the details and embellishments, and let the student refer to the text for the theory and basics, then this book would be ideal.