Cleaning data of errors in structure and content is important for data warehousing and integration. Current solutions for data cleaning involve many iterations of data "auditing" to find errors, and long-running transformations to fix them. Users need to endure long waits, and often write complex transformation scripts. We present Potter's Wheel, an interactive data cleaning system that tightly integrates transformation and discrepancy detection. Users gradually build transformations to clean the data by adding or undoing transforms on a spreadsheet-like interface; the effect of a transform is shown at once on records visible on screen. These transforms are specified either through simple graphical operations, or by showing the desired effects on example data values. In the background, Potter's Wheel automatically infers structures for data values in terms of user-defined domains, and accordingly checks for constraint violations. Thus users can gradually build a transformation as discrepancies are found, and clean the data without writing complex programs or enduring long delays. 1

Visual query systems (VQSs) are query systems for databases that use visual representations to depict the domain of interest and express related requests. VQSs can be seen as an evolution of query languages adopted into database management systems; they are designed to improve the effectiveness of the human-computer communication. Thus, their most important features are those that determine the nature of the human-computer dialogue. In order to survey and compare existing VQSs used for querying traditional databases, we first introduce a classification based on such features, namely the adopted visual representations and the interaction strategies. We then identify several user types and match the VQS classes against them, in order to understand which kind of system may be suitable for each kind of user. We also report usability experiments which support our claims. Finally, some of the most important open problems in the VQS area are described. 1.

ABSTRACT We use the term "marking interactions " to describe The direct manipulation paradigm has been effective in helping designers create easy to use mouse and keyboard based interfaces. The development of flat display surfaces and transparent tablets are now making possible interfaces where a user can write directly on the screen using a special stylus. The intention of these types of interfaces is to exploit user's existing handwriting, mark-up and drawing skills while also providing the benefits of direct manipulation. This paper reports on a test bed program which we are using for exploring hand-marking types of interactions and their integration with direct manipulation interactions.

We identify a problem with the process of research in the HCI community -- an overemphasis on "radical invention" at the price of achieving a common research focus. Without such a focus, it is difficult to build on previous work, to compare different interaction techniques objectively, and to make progress in developing theory. These problems at the research level have implications for practice, too; as

One of the problems with conventional UIMSs is that very often there is no graphical way to specify interfaces. This paper describes OPUS, the user interface editor of the Penguims UIMS. This system allows the presentation component of graphical user interfaces to be specified interactively in a graphical notation without explicit programming. The Penguims UIMS supports an underlying model of computation based loosely on spreadsheets. In particular, it supports incremental computations based on a system of equations (one-way constraints) over a set of named values (spreadsheet cells). These equations are used to provide immediate feedback at all levels of the interface. They are used to incrementally determine the position and dynamic appearance of the individual interactor objects that make up the interface. They are also used to connect the presentation directly to underlying application data thereby supporting semantic feedback. The OPUS user interface editor employs a special graphical notation for specifying the presentation component of a user interface. This notation allows the power of the underlying computational model to be expressed simply and quickly. The resulting presentations are very flexible in nature. They can automatically respond to changes in the size and position of display objects and can directly support derivation of their appearance from application data objects.

Constraints and dependencies among the elements of embodied cognition form patterns or microstrategies of interactive behavior. Hard constraints determine which microstrategies are possible. Soft constraints determine which of the possible microstrategies are most likely to be selected. When selection is non-deliberate or automatic the least effort microstrategy is chosen. In calculating the effort required to execute a microstrategy each of the three types of operations, memory retrieval, perception, and action, are given equal weight; that is, perceptual-motor activity does not have a privileged status with respect to memory. Soft constraints can work contrary to the designer's intentions by making the access of perfect knowledge in-the-world more effortful than the access of imperfect knowledge in-the-head. These implications of soft constraints are tested in two experiments. In experiment 1 we varied the perceptual-motor effort of accessing knowledge in-the-world as well as the effort of retrieving items from memory. In experiment 2 we replicated one of the experiment 1 conditions to collect eye movement data. The results suggest that milliseconds matter. Soft constraints lead to a reliance on knowledge in-the-head even when the absolute difference in perceptual-motor versus memory retrieval effort is small, and even when relying on memory leads to a higher error rate and lower performance. We discuss the implications of # Supplementary data associated with this article can be found, in the online version, at doi:10.1016/ j.cogsci.2003.12.001 ## An earlier, much simpler version of this report was presented as an eight-page conference paper at CHI2001. That paper is archived as Gray and Fu (2001).

Claims have been proposed as a means of expressing HCI knowledge that is associated with a specific artefact and usage context. Claims describe design trade-offs and record HCI knowledge related to a specific design, or artefact, as psychological design rationale. Claims are created in the task-artefact cycle of interactive design and evaluation. Usability evaluation establishes a claim for a specific usage context, but this can restrict subsequent reuse of claims related knowledge. To widen the scope of reuse the knowledge contained within claims and their associated artefacts has to be classified and generalized. To address this problem a schema and method for classifying claims is introduced. The schema elaborates the description of HCI knowledge in claims and enables reuse by describing the assumptions and dependencies upon which a claim rests. Methods for generalising claims and discovering new claims from existing claims and artefacts were investigated. A factoring method for evolving child claims from parent claims and their usage scenarios is described. This employs a walkthrough technique based on Norman’s model of action with questions directed at the contributions a claim makes to usability at different stages in interaction. Factoring promotes evolution of child claims that either address different aspects of task support in the same domain as the parent claim, or development of more general child claims for user interface design. The relationships between claims are represented in maps to illustrate histories of task-artefact investigation that lead to claims evolution either via the factoring process or by empirical investigation. The schema and method for claims evolution are illustrated by case studies of claims development in tutoring systems and claims for functional requirements for specification reuse support tools. The paper concludes with a discussion of the contribution that reusable claims can make as a repository of HCI knowledge. 1 1.

This paper describes a computational model of skilled use of a graphical user interface and of errors made by skilled users. The model is based of Norman's action framework and is implemented using Kintsch's construction-integration theory. The model selects actions, such as moving mouse cursor, clicking mouse button, typing letters, and so on, by integrating information from various sources. These sources include the display, task goals, expected device states, and knowledge about the interface and the application domain. We show how information about the intermediate states of a task presented on a display plays a critical role in skilled performance. The model also

This paper describes a new interactive environment for user interface specification which is based on an enhanced spreadsheet model of computation. This environment allows sophisticated graphical user interfaces with dynamic feedback to be implemented with little or no explicit programming. Its goal is to support user interface specification by non-programming experts in human factors, visual design, or the application domain. In addition, the system is designed to allow sophisticated end-users to modify and customize their own interfaces. The system is based on a data flow model of computation. This model is presented to the interface designer in the form of a spreadsheet enhanced with new constructs for easier programming and reuse. These constructs include an improved interactive programming environment, a prototype-instance based inheritance system, support for composition, abstraction, and customization using indirect references, the addition of support for graphical inputs and ou

The design of theorem provers, especially in the LCF-prover family, has strongly profited from functional programming. This paper attempts to develop a metaphor suited to visualize the LCF-style prover design, and a methodology for the implementation of graphical user interfaces for these provers and encapsulations of formal methods. In this problem domain, particular attention has to be paid to the need to construct a variety of objects, keep track of their interdependencies and provide support for their reconstruction as a consequence of changes. We present a prototypical implementation of a generic and open interface system architecture, and show how it can be instantiated to an interface for Isabelle, called IsaWin, as well as to a tailored tool for transformational program development, called TAS.