Constraint Logic Programming (CLP) is a merger of two declarative paradigms: constraint solving and logic programming. Although a relatively new field, CLP has progressed in several quite different directions. In particular, the early fundamental concepts have been adapted to better serve in different areas of applications. In this survey of CLP, a primary goal is to give a systematic description of the major trends in terms of common fundamental concepts. The three main parts cover the theory, implementation issues, and programming for applications.

We address a global constraint for enforcing contiguity. Contiguity is the property that all of one kind of object in an array or list are grouped together; it is a one-dimensional discrete form of convexity. We present an implementation of this property in a concurrent constraint programming language. We adapt and apply the constraint propagation framework of [19] to analyse the contiguity property. In particular, the soundness of the implementation is proved and the forms of local consistency that are maintained by the implementation are identified. A complexity analysis shows that the implementation is optimal for achieving arc-consistency. However, an optimal implementation is not given for a stronger consistency condition, and we raise the possibility that an optimal implementation requires meta-level programming.

COCA (Collaborative Objects Coordination Architecture) was proposed as a novel means to model and support collaborations over the Internet. Our approach separates coordination policies from user interfaces and the policies are specified in a logic-based language. Over the past year, both the collaboration model and the specification language have been substantially refined and evaluated through our experience in building real-life collaboration systems. This paper presents the design of the specification language and illustrates the main ideas with a few simple design examples. Semantics, implementation, runtime support, and applications are also covered but not as the focus of this paper.

We develop a framework for addressing correctness and timeliness-of-propagation issues for reactive constraints - global constraints or user-defined constraints that are implemented through constraint propagation. The notion of propagation completeness is introduced to capture timeliness of constraint propagation. A generalized form of arc-consistency is formulated which unifies many local consistency conditions in the literature. We show that propagation complete implementations of reactive constraints achieve this arc-consistency when propagation quiesces. Finally, we use the framework to state and prove an impossibility result: that CHR cannot implement a common relation with a desirable degree of timely constraint propagation.

The tcc model is a concurrent constraint programming formalism for timed, reactive and deterministic computation. A remarkable feature of the tcc model is that programs and specifications are given in the same language. In this report we develop an extension of tcc that allows the specification of nondeterministic computation. We call this extension the ntcc model. The ntcc model is based upon ideas from both concurrent constraint programming and CCS-like models. The expressiveness of ntcc is illustrated by showing derived constructs such as parameterless recursion, cells and value-broadcasting processes, and by specifying temporal requirements such as eventuality, time-bounded response and time-bounded invariance. We claim the applicability of ntcc by modeling reactive system examples of RCX controllers. We present ongoing work on a denotational semantics and a proof system for the model. In the spirit of Process Algebra, we also define a behavioral equivalence for the ntcc model based upon the notion of (weak) bisimulation.