. Constraints allow programmers and users to state declaratively a relation that should be maintained, rather than requiring them to write procedures to maintain the relation themselves. They are thus useful in such applications as programming languages, user interface toolkits, and simulation packages. In many situations, it is desirable to be able to state both required and preferential constraints. The required constraints must hold. Since the other constraints are merely preferences, the system should try to satisfy them if possible, but no error condition arises if it cannot. A constraint hierarchy consists of a set of constraints, each labeled as either required or preferred at some strength. An arbitrary number of different strengths is allowed. In the discussion of a theory of constraint hierarchies, we present alternate ways of selecting among competing possible solutions, and prove a number of propositions about the relations among these alternatives. We then outline algorit...

this paper we argue that many user interface construction problems are handled more naturally and elegantly by multi-way constraints than by one-way constraints. We present pseudocode for an incremental multi-way constraint satisfaction algorithm, DeltaBlue, and describe experience in using the algorithm in two user interface toolkits. Finally, we provide performance figures demonstrating that multi-way constraint solvers can be entirely competitive in performance with one-way constraint solvers

Two major paradigms in computer programming languages are imperative and declarative programming. We describe a scheme for languages that integrate specific features from these two paradigms into a new framework: Constraint Imperative Programming. Along with the framework, we discuss the design and implementation of a particular instance of this framework, Kaleidoscope'90. From the imperative paradigm, constraint imperative programming adopts explicit control flow, state, and assignment. From the declarative paradigm, it adopts explicit, systemmaintained constraints (relations that should hold). There is a strong practical motivation for making this integration: in a typical application, some portions are most clearly described using imperative constructs, while other portions are most clearly described using constraints. By using a constraint imperative language, the most suitable paradigm can be used as appropriate. 1 Introduction We propose to combine two simple techniques--- decl...

The Constraint Imperative Programming (CIP) family of languages integrates constraints and imperative, object-oriented programming. In addition to combining the useful features of both paradigms, there are synergistic effects of this integration, such as the ability to define constraints over user-defined domains. We discuss characteristics of the CIP family and provide a rationale for its creation. The synergy of constraints and objects imposes additional challenges for the provision of constructs, such as object identity and class membership, that are well-understood in conventional language paradigms. We discuss the benefits and challenges of combining the constraint and imperative paradigms, and present our current ideas in the context of the design and implementation of the Kaleidoscope'93 language.

. Constraint Imperative Programming (CIP) languages integrate declarative constraints with imperative state and destructive assignment, yielding a powerful new programming paradigm. However, CIP languages are difficult to implement efficiently due to complex interactions between the two donor paradigms. Neither the virtual machines for classical object-oriented languages, nor those for existing constraint languages, are suitable for implementing CIP languages, as each assumes a purely imperative or a purely declarative computation model. We have developed a new virtual machine for CIP languages, the K-machine, an imperative machine with an incremental constraint solver and a constraint-based, rather than value-based, data store. This virtual machine allows user-defined constraints to be defined using constraint constructor definitions which are the CIP analog to method definitions. Similar to methods, these constructors are able to reference variables indirectly through many levels of ...

Most of today's Graphical User Interfaces (GUI) and toolkits are based on serial, discrete, token based, paradigms that seem to acceptably implement traditional WIMP (Window, Icon, Menu, Pointer) interfaces. These tools however, are not suited for "next generation" interaction techniques such as Virtual Reality (VR). These interaction techniques rely upon asynchronous, parallel, and continuous user/computer interaction. This work proposes a specification paradigm, DLoVe, which provides a framework of techniques and abstractions that directly addresses these issues. In addition, DLoVe also provides a mechanism for executing programs designed for a single machine to be executed in a distributed environment, where updates on DLoVe variables are processed in parallel. DLoVe's framework also provides the abstractions for writing multi-user VR programs or transforming existing single-user programs into multi-user ones. Moreover, DLoVe addresses issues of performance and maintainability, providing mechanisms, drivers, and utilities that allow run time tuning and network management to be specified in a simple manner. This thesis describes in detail the proposed system, evaluates it, and provides examples and analysis of several applications developed within DLoVe's paradigm, and provides a guide on how applications can be implemented in this framework.

The event-driven, or reactive, programming style of the contemporary CUt is a major reason they are difficult to program. This is compounded in a distributed application. The reactive style, however, reflects the mismatch between multithreaded interfaces and a single threaded process, and is actually the equivalent of continuation passing style, a source code transformation used by some compilers. Using continuations for callbacks eliminates much of the difficulty of the reactive style. We describe a toolkit for managing the multiple threads of control which can be combined with existing CUI toolkits and which supports distributed applications.