Bradley T. Vander Zanden

The importance of pointer variables in constraint models

Graphical tools are increasingly using constraints to specify the graphical layout and behavior of many parts of an application. However, conventional constraints directly encode the objects they reference, and thus cannot provide support for the dynamic rttntime creation and manipulation of application objects. This paper discusses an extension to current constraint models that allows constraints to indirectly reference objects through pointer variables. Pointer variables permit programmers to create the constraint equivalent of procedures in traditional programming languages. This procedural abstraction allows constraints to model a wide array of dynamic application behavior, simplifies the implementation of structured object and demonstrational systems, and improves the storage and efficiency of highly interactive, graphical applications. It also promotes a simpler, more effective style of programming than conventional constraints. Constraints that use pointer variables are powerful enough to allow a comprehensive user interface toolkit to be built for the first time on top of a constraint system.

Lessons learned about one-way, dataflow constraints in the Garnet and Amulet graphical toolkits

One-way, dataflow constraints are commonly used in graphical interface toolkits, programming environments, and circuit applications. Previous papers on dataflow constraints have focused on the design and implementation of individual algorithms. In contrast, this article focuses on the lessons we have learned from a decade of implementing competing algorithms in the Garnet and Amulet graphical interface toolkits. These lessons reveal the design and implementation tradeoffs for different one-way, constraint satisfaction algorithms. The most important lessons we have learned are that (1) mark-sweep algorithms are more efficient than topological ordering algorithms; (2) lazy and eager evaluators deliver roughly comparable performance for most applications; and (3) constraint satisfaction algorithms have more than adequate speed, except that the storage required by these algorithms can be problematic.

Constraint grammars–a new model for specifying graphical applications

User Interface Management Systems often attempt to separate the graphical and nongraphical aspects of an application, but rarely succeed. Constraint grammars provide a new model for specifying interfaces that achieves this goal by encapsulating the data structures in a single package, and providing a powerful transformation-based editing model for manipulating them. Constraint grammars incorporate a number of important tools, such as the part-whole hierarchy, almost hierarchical structures, and multidirectional constraints, that permit designers to specify a wide variety of graphical applications, including simulation systems, program visualization systems, and visual programming environments.

Parallelization of the Hoshen-Kopelman Algorithm Using a Finite State Machine

In applications such as landscape ecology, computer mod eling is used to assess habitat fragmentation and its ecological implications. Maps (two-dimensional grids) of habitat clusters or patches are analyzed to determine the number, location, and sizes of clusters. Recently, improved sequential and parallel implementations of the Hoshen- Kopelman cluster identification algorithm have been designed. These implementations use a finite state ma chine to reduce redundant integer comparisons during the cluster identification process. The sequential implementa tion for large maps performs cluster identification by par titioning the map along row boundaries and merging the results of the partitions. The parallel implementation on a 32-processor Thinking Machines CM-5 provides an effi cient mechanism for performing cluster identification in parallel. Although the sequential implementation achieved promising speed improvements ranging from 1.39 to 2.00 over an existing Hoshen-Kopelman implementation, the parallel implementation achieved a minimum speedup of 5.41 over the improved sequential implementation, exe cuted on a Sun SPARCstation 10.

Minimum density RAID-6 codes

RAID-6 codes protect disk array storage systems from two-disk failures. This article presents a complete treatment of a class of RAID-6 codes, called minimum density RAID-6 codes, that have an optimal blend of performance properties. There are two families of minimal density RAID-6 codes: Blaum-Roth codes and Liberation codes, and a separate special-purpose code called the Liber8tion code. The first of these have been known since the late 1990s, while the latter two are new constructions. In this article, we motivate, demonstrate, and evaluate the minimum density codes, comparing them to EVENODD and RDP codes, which represent the state-of-the-art in RAID-6. Following that, we prove that the codes indeed fit the RAID-6 methodology, and cite their implementation in an open-source library.

ALEX an Alexical Programming Language

ALEX is an experimental language for high-level parallel programming. It is a testbed for exploring various non-traditional ways of expressing algorithmic ideas, making extensive use of high-resolution color graphics. The language itself is not a programming language in the traditional sense, since there is no lexical syntax. This paper discusses the basic design of the ALEX user interface.

A general framework for computing block accesses

A physical database system design should take account of skewed block access distributions, nonuniformly distributed attribute domains, and dependent attributes. In this paper we derive general formulas for the number of blocks accessed under these assumptions by considering a class of related occupancy problems. We then proceed to develop robust and accurate approximations for these formulas. We investigate three clases of approximation methods, respectively based on generating functions, Taylor series expansions, and majorization. These approximations are as simple to use and far more accurate than the cost estimate formulas generated by making independence and uniformity assumptions.

Experiments with algorithm visualization tool development

This paper presents the initial stages of a teaching tool named iSketchmate, intended for instructor use during lecture. iSketchmate allows users to create and manipulate splay trees through an animated GUI. It improves upon existing tools by providing (1) the ability to begin with any user-defined tree, (2) a history mechanism so tree operations can be repeated or changed, and (3) finer-grained animation within each operation so instructors may give further descriptions at intermediate steps within any given operation. Experiments showed iSketchmate users could produce significantly more diagrams and these diagrams were significantly more accurate than those made with pencil and paper.

An empirical study of constraint usage in graphical applications

One-way constraints have been widely incorporated in research toolkits for constructing graphical applications. However, although a number of studies have examined the performance of these toolkits’ constraint satisfaction algorithms, there have not been any empirical studies that have examined how programmers use constraints in actual applications. This paper reports the results of a study intended to address these matters. Seven graphical applications were chosen for their diversity and profiling information was gathered about their use of constraints, The data reveal that constraint networks tend to be modular, that is, divided into a number c~fsmall, independent sets of constraints rather than one mono] ithic set of constraints. This finding suggests that constraint satisfaction algorithms should be able to resatisfy constraints rapidly after a change to one or more variables. It also suggests that debugging constraints should not be unduly burdensome on a programmer since the number of constraints that must be examined to find the source of an error is not terriblly large. Overall, the results of this study should provide a repository of data that will be useful in directing future research on optimizing constraint solvers and developing effective debugging techniques.

Two experiments using learning rate to evaluate an experimenter developed tool for splay trees

We conducted two experiments evaluating Sketchmate, a tool used to teach the splay tree data structure and its algorithms. Learning and learning rates were compared across two groups, one using Sketchmate and the other using paper-and-pencil on practice problems. Results from Experiment I showed that when students used Sketchmate with minimal feedback, there were no significant differences across learning, time spent learning, or learning rate. Experiment II used a version of Sketchmate that provided richer feedback. Results showed similar learning but Sketchmate took significantly less time. Thus when feedback was added, learning rates were significantly greater relative to the paper-and-pencil condition. Discussion focuses on measuring learning rates when evaluating instructional tools.