Constraint-based execution and concurrency are valuable allies, but they are not natural ones. This book examines ways in which constraints and concurrency can be brought into harmony. The results reported show how constraints can be trimmed for potentially better concurrent execution, and how concurrency can be exploited to produce effective constraint-based execution environments.

The book has three parts surrounded by introductory and summary chapters. Part 1 devotes a chapter each to high-level, concise descriptions of constraints and concurrency. The three chapters in Part 2 cover concurrency’s influence on constraint languages. The fourth chapter describes the constraint-based language constraint handling rules (CHR). The remaining two chapters take up CHR variants that may be better suited for concurrent execution. Part 3 discusses concurrent constraint evaluation in four chapters. Chapter 7 describes a distributed framework that uses a service-oriented computing model for satisfying constraint problems. Chapter 8 takes up the problem of using dataset properties to select appropriate constraint-satisfaction techniques. The remaining two chapters consider concurrency-enhancing modifications to Jolie, a language supporting service-oriented computing. An appendix presents proofs of claims made in the text, mainly from chapters 5 and 6 about CHR-variant properties.

Concurrency in this book means large-grained concurrency, such as that found in distributed systems. The CHR modifications in Part 2 are motivated by the collective concurrency available in mobile and other small computing devices. Such devices are not good execution engines for unencumbered CHR, leading to a search for modifications producing more appropriate execution profiles while minimally reducing expressive power. The results are successful and entirely theoretical. Chapter 5 trims CHR in various ways to produce language variants that are strictly less powerful than Turing machines, but are, in one variant, as expressive as Petri nets. Chapter 6 explores priorities in CHR, showing that dynamic priorities are no more powerful than static priorities, and that CHR with static priorities can be translated to a restricted CHR without priorities.

Part 3 is organized around the concurrency in clouds (CiC) distributed framework for constraint satisfaction. Apart from CiC, Part 3 doesn’t have much to do with constraints proper. Chapter 8 describes how machine learning can use problem properties to pick appropriate constraint solvers. The machine learning algorithms don’t seem to be implemented with constraints. Jolie, the subject of chapters 9 and 10, doesn’t seem to be a constraint-based language (in fact, it’s unclear if CiC is implemented in Jolie). The Jolie modifications described are broadcast messages (chapter 9) and interruptible service behavior (chapter 10).

The background requirements for this book are modest. Chapters 2 and 3 are enough to inform an otherwise capable reader. Familiarity with constraint or logic programming will help readers get through the more theoretical sections of chapters 5 and 6. The bibliography is appropriately selective but detailed. At the level set by the subject matter, the book is pleasant to read.