Bjørn N. Freeman-Benson

An incremental constraint solver

An incremental constraint solver, the DeltaBlue algorithm maintains an evolving solution to the constraint hierarchy as constraints are added and removed. DeltaBlue minimizes the cost of finding a new solution after each change by exploiting its knowledge of the last solution.

Multi-way versus one-way constraints in user interfaces: experience with the DeltaBlue algorithm

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.

The OTI Constraint Solver: A Constraint Library for Constructing Interactive Graphical User Interfaces

ENVY/Constraints is an IBM/Smalltalk library that provides a constraint satisfier and a collection of useful constraints, targeted at developing interactive graphical user interfaces. The solver supports multi-way constraints and constraint hierarchies. It uses a hybrid algorithm, combining local propagation with pluggable cycle solvers, allowing constraints to range over arbitrary objects, while at the same time satisfying constraints representing simultaneous equations over the reals.

Kaleidoscope: A Constraint Imperative Programming Language

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.

The DeltaBlue algorithm: an incremental constraint hierarchy solver

Constraint programming allows the behavior of a program to be specified declaratively in terms of constraints. A constraint is a system-maintained assertion about the desired state of the programs data structures. To specify the behavior of a system of constraints more precisely, the authors have found it useful to separate constraints into levels according to their relative importance, creating a constraint hierarchy. Constraint hierarchies have been used effectively in such applications as interactive simulations and user interface construction. Future applications of constraint programming will make more frequent changes to the constraint hierarchy at runtime, placing stringent performance requirements on the constraint solver. Previous algorithms for solving constraint hierarchies analyzed the entire constraint hierarchy on each invocation and thus were not well matched to the job of resatisfying the hierarchy after small changes. The authors present an incremental constraint solver, DeltaBlue, that maintains a solution to the constraint hierarchy as constraints are added and removed. DeltaBlue minimizes the cost of finding a new solution after each change by utilizing its knowledge of the current solution. The DeltaBlue algorithm is designed to produce locally predicate-better solutions when the constraint hierarchy can be solved by local propagation. That is, it does not handle cycles in the constraint graph, but will detect them and can then call a more powerful algorithm.<<ETX>>

Converting an existing user interface to use constraints

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.

YP and urban simulation: applying an agile programming methodology in a politically tempestuous domain

YP is an agile programming methodology that has evolved over the past 15 years. Many of its features are common to other agile methodologies; its novel features include using a highly visible, physical software status indicator (a real traffic light), and a well-defined nested set of development cycles. It is also an exceptionally open process, with the current status of the development process visible to the customers, as well as the code and documentation. We are using YP in developing the software for UrbanSim, a sophisticated simulation system for modeling urban land use, transportation, and environmental impacts over periods of 20 or more years under alternate possible scenarios. Our purpose in developing UrbanSim is to support public deliberation and debate on such issues as building a new light rail system or freeway, or changing zoning or economic incentives, as well as on broader issues such as sustainable, livable cities, economic vitality, social equity, and environmental preservation. The domain of use is thus politically charged, with different stakeholders bringing strongly held values to the table. Our goal is to not favor particular stakeholder values in the simulation or its output, but rather to let different stakeholders evaluate the results in light of what is important to them. There are several implications of this for the development process. First, having credible, reliable code is important - and further, both the code itself and the development process that produced it should be open and inspectable, not a black box. Second, to allow us to respond quickly to different stakeholder values and concerns, a flexible agile development process is required.

A module mechanism for constraints in Smalltalk

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 ).

DeltaStar: a general algorithm for incremental satisfaction of constraint hierarchies

The DeltaStar incremental algorithm for solving constraint hierarchies, which was developed as part of a continuing investigation on the design and implementation of constraint programming languages, is described. DeltaStar is a framework for incremental solvers built above an existing flat solver that provides the constraint solving techniques. By plugging different flat solvers into DeltaStar, different hierarchical solvers can quickly be produced and experimented with. Two implementations of DeltaStar, as well as previous algorithms that can be viewed as instances of DeltaStar, are discussed.<<ETX>>

Constraint hierarchies and their applications

The authors describe how they have used constraints and constraint hierarchies in three different systems: ThingLab II, a system written in Smalltalk-80 for building user interfaces; HCLP, a new programming language that integrates constraint hierarchies with logic programming; and Kaleidoscope, another programming language that combines constraint hierarchies with imperative programming constructs (state and assignment), as well as with object-oriented programming. Also described are the algorithms these systems require for finding solutions to constraint hierarchies.<<ETX>>