Dynamic information collected as a software system executes can help software engineers perform some tasks on a system more effectively. To interpret the sizable amount of data generated from a system's execution, engineers require tool support. We have developed an off-line, flexible approach for visualizing the operation of an object-oriented system at the architectural level. This approach complements and extends existing profiling and visualization approaches available to engineers attempting to utilize dynamic information. In this paper, we describe the technique and discuss preliminary qualitative studies into its usefulness and usability. These studies were undertaken in the context of performance tuning tasks.

Inequality constraints are useful for specifying various aspects of user interfaces, such as constraints that clne window is to the left of another, or that an object is contained within a rectangle.However, current local propagation constraint solvers can't handle inequality constraints.We present Indigo, an efficient local propagation algorithm for satisfying acyclic constraint hierarchies, including inequality constraints.

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 pointers. The K-machine maintains relations between objects in the presence of state change to these indirectly referenced objects. The K-machine is capable of supporting a wide variety of CIP languages, including our most recent: Kaleidoscope'93.

Constraints have long been championed as a tool for user interface construction.However, while certain constraint systems have established a user community, constraint-based user interfaces have not yet been widely adopted.The pmxnise of this paper is that a major stumbling block to their pervasive use has been the emphasis on designing new interface toolkits rather than augmenting existing ones.The thesis of the work described in this paper is that it is possible, and practical, to convert an existing user interface written in an imperative programming language into a similar user interface implemented with constraints.This thesis is proved by example: the conversion of HotDraw into CoolDraw.KEVWORDS user interface toolkits, constraints, conversion, HotDraw, CoolDraw, direct manipulation MOTIVATION Constraints have long been championed as a tool for user interface construction.The user interface research and development community has developed constraint algorithms, interface toolkits, and even complete systems based on constraints.And, while systems like Garnet Myers et al. 90] have established a user community, constraint-based user interfaces have not yet been widely adopted.The premise of this paper is that a major stumbling block to their pervasive use has been the emphasis on designing new interface toolkits rather than augmenting existing ones.And, as the real demonstration of a toolkit's utility is its use in full-scale applications, these new, fledging toolkits are handicapped developers cannot afford to adopt incomplete tools while researchers cannot afford to build full-scale ones.However, if existing tools could be adapted or converted to use the researchers' ideas, these ideas could be explored in full-scale applications for significantly less cost.The thesis of the work described in this paper is that it is possible, and practical, to convert an existing user inter-

Abstract The efficient satisfaction of constraints is essential to the performance of constraint‐based user interfaces. In the past, most constraint‐based user interfaces have used one‐way rather than multi‐way constraints because of a widespread belief that one‐way constraints were more efficient. In 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.

ThingLab II, a rewrite of ThingLab, provides two representations of objects: fully-exposed and interpreted Things, or hidden and compiled Modules. Both representations provide the full power of the ThingLab II constraint hierarchy (an ordering of constraint preferences), and both can be manipulated by the graphical user-interface. This paper briefly describes Modules and their environmental support in ThingLab II. It also describes the process by which the ModuleCompiler translates a collection of objects (a ThingLab II Thing) into a single object with compiled and optimized Smalltalk-80 methods (a Module).

ThingLab II is an object-oriented constraint programming system designed specifically for interactive user interface construction and implemented in Smalltalk-80 For constraints to be effective in building user interfaces, they must not impede the responsiveness of the user interface either at run time or during construction. The necessary speed is attained in ThingLab II by making judicious tradeoffs between compilation and interpretation, and by using a fast, incremental algorithm for constraint satisfaction. The resulting system allows user interface components to be assembled, tested, and modified expediently while maintaining interactive responsiveness.

Constraints describe relations that must be maintained, and provide a useful tool for such applications as interactive simulations, algorithm animation, and graphical user interface construction. We describe a major overhaul and extension to the constraint satisfaction mechanism in ThingLab, a constraint-oriented simulation laboratory written in the Smalltalk-80 language. First, a specification is presented of constraint hierarchies. Such hierarchies include both required constraints and default constraints of differing strengths, thus adding considerable expressive power to the system. Second, an algorithm for satisfying constraint hierarchies is described. The new satisfier is substantially faster than the previous version, even though it also includes new functionality.