Symbol design: a user-centered method to design pen-based interfaces and extend the functionality of pointer input devices

A method called “SymbolDesign” is proposed that can be used to design user-centered interfaces for pen-based input devices. It can also extend the functionality of pointer input devices, such as the traditional computer mouse or the Camera Mouse, a camera-based computer interface. Users can create their own interfaces by choosing single-stroke movement patterns that are convenient to draw with the selected input device, and by mapping them to a desired set of commands. A pattern could be the trace of a moving finger detected with the Camera Mouse or a symbol drawn with an optical pen. The core of the SymbolDesign system is a dynamically created classifier, in the current implementation an artificial neural network. The architecture of the neural network automatically adjusts according to the complexity of the classification task. In experiments, subjects used the SymbolDesign method to design and test the interfaces they created, for example, to browse the web. The experiments demonstrated good recognition accuracy and responsiveness of the user interfaces. The method provided an easily-designed and easily-used computer input mechanism for people without physical limitations, and, with some modifications, has the potential to become a computer access tool for people with severe paralysis.     

Implementing a user interface management system for existing applications using an object-oriented database tool

Numerous engineering application systems have been developed over the past twenty years, and many of these applications will continue to be used for many years to come. Examples of such applications include CAD Systems, finite-element analysis packages and inspection systems. Because many of these applications were developed before graphical workstations became available, they often have simple command-line user interfaces. Thus, there is a need for a graphical user interface management system (UIMS) that can be used to build point-and-click style interfaces for these existing engineering applications. In this paper we describe such a UIMS, and discuss its implementation using an object-oriented database tool. This UIMS allows users to create and modify user interfaces by editing graphical representations of the interfaces, thus eliminating the need to write code to build or modify an interface. The UIMS is implemented using an object-oriented database tool to take advantage of the data manipulation and storage management capabilities it provides. This approach reduces both the quantity and complexity of the code needed to implement the UIMS. It also allowed the UIMS to be implemented in a minimal amount of time.     

A multi-formalism approach for model-based dynamic distribution of user interfaces of critical interactive systems

Evolution in the context of use requires evolutions in the user interfaces even when they are currently used by operators. User Centered Development promotes reactive answers to this kind of evolutions either by software evolutions through iterative development approaches or at runtime by providing additional information to the operators such as contextual help for instance. This paper proposes a model-based approach to support proactive management of context of use evolutions. By proactive management we mean mechanisms in place to plan and implement evolutions and adaptations of the entire user interface (including behaviour) in a generic way. The approach proposed handles both concentration and distribution of user interfaces requiring both fusion of information into a single UI or fission of information into several ones. This generic model-based approach is exemplified on a safety critical system from space domain. It presents how the new user interfaces can be generated at runtime to provide a new user interface gathering in a single place all the information required to perform the task. These user interfaces have to be generated at runtime as new procedures (i.e. sequences of operations to be executed in a semi-autonomous way) can be defined by operators at any time in order to react to adverse events and to keep the space system in operation. Such contextual, activity-related user interfaces complement the original user interfaces designed for operating the command and control system. The resulting user interface thus corresponds to a distribution of user interfaces in a focus+context way improving usability by increasing both efficiency and effectiveness.     

DUET — A database user interface design environment

The DUET database user interface management system aims to help database application programmers to create, modify, and maintain interactive graphical user interfaces for different applications. DUET supports the creation of a complete user interface via direct manipulation techniques. It provides a large set of database widgets which are necessary for database applications. DUET provides facilities to step through the validation of a created user interface. A user interface can be saved as C code which can be integrated into a database backend. In this paper, the features and the architecture of DUET are presented.     

Vehicle Routing and Production Planning Decision Support Systems: Designing Graphical User Interfaces

Given the inherent complexity of vehicle routing and production planning decision support systems, designing user interfaces for them is challenging and can make a big difference in the usability of these systems. Many heuristic and optimization-oriented systems that have been implemented for this type of problem have failed in part due to a poor graphical user interface. This work proposes an approach that can be applied to improve the design of user interfaces for this type of system and make its implementation easier. The approach is based on tools that were adapted from the FW/SM system for Structured Modeling and commercially available tools, such as Powerbuilder and CPLEX. Two systems that were implemented using this approach, in two different firms, are presented. These systems run on standard PCs under MS Windows, follow the Windows applications design guidelines, and interact with relational database management systems.     

CIRL/PIWI: A GUI toolkit supporting retargetability

Writing applications that are easily moved to various computer platforms with different graphical user interfaces (GUIs) is a complex task. Yet this concept is important for the creator of commercial software, as it is not likely to be clear for many years whether one or two GUIs will survive and become industry ‘standards’ or whether the growth in GUIs will continue because of new developments in human-computer interfaces. Providing a user interface abstraction that maps into all toolkits seems to be an appropriate way to proceed, but is fraught with difficulty. For example, different GUIs present a different look-and-feel that often causes system-specific information to be embedded in an application. This paper surveys the problems inherent in designing a user interface abstraction, and describes the experiences gained from a specific implementation called CIRL/PIWI.

1 CIRL and PIWI are acronyms for Co-ordinate-Independent Resource Language and Presentation-Independent Windowed Interface.

The user interface abstraction contains a knowledge base that allows many components of the user interface to be defined independent of look-and-feel thereby increasing the portability of an application.     

A graphical user interface server for unix

The UNIX operating system has attained widespread popularity because of its power, flexibility and elegance. However, the common user interfaces (shells) have been criticized as being cryptic and difficult to use, especially for novices. In this paper, we present a user interface server that can be used to provide a graphical shell for UNIX. This shell helps to overcome a number of difficulties faced by both novices and experts. Although it is largely intended to assist novices, it is also designed not to become a hindrance for expert users and does not sacrifice the basic power and flexibility of UNIX. The server is designed to augment rather than replace text-based interfaces and can be used from a variety of different interactive programs in addition to shells.     

Integrated systems II: Multi-tier interfaces for integrating families of systems

Of critical importance is the design of the man-machine interfaces for general rule based systems. They must serve (i) as user-friendly interfaces for different classes of users for different applications and (ii) to invoke service components in integrated packages without interrogating users. These objectives are achieved with a multitier interface design whose two parts, the Interactive User-Friendly Interface (IUFI) and the System Interface (SI), communicate with each other via commonly used notational systems and can be invoked independently of each other. The user-friendly interface, which is uniquely designed for each user discipline, passes information to the SI. The SI does not change for new IUFI designs and it can be invoked by other rule based systems without interrogating users.Here the requirements for the IUFI and SI parts are identified, four different designs of multi-tier interfaces are given and two applications are described. Also included are guidelines for designing user friendly interfaces.     

A formal model for plastic human computer interfaces

The considerable and significant progress achieved in the design and development of new interaction devices between man and machine has enabled the emergence of various powerful and efficient input and/or output devices. Each of these new devices brings specific interaction modes.With the emergence of these devices, new interaction techniques and modes arise and new interaction capabilities are offered. New user interfaces need to be designed or former ones need to evolve. The design of so called plastic user interfaces contributes to handling such evolutions. The key requirement for the design of such a user interface is that the new obtained user interface shall be adapted to the application and have, at least, the same behavior as the previous (adapted) one. This paper proposes to address the problem of user interface evolution due to the introduction of new interaction devices and/or new interaction modes. More, precisely, we are interested by the study of the design process of a user interface resulting from the evolution of a former user interface due to the introduction of new devices and/or new interaction capabilities. We consider that interface behaviors are described by labelled transition systems and comparison between user interfaces is handled by an extended definition of the bi-simulation relationship to compare user interface behaviors when interaction modes are replaced by new ones.     

Exploring MARS: developing indoor and outdoor user interfaces to a mobile augmented reality system

We describe an experimental mobile augmented reality system (MARS) testbed that employs different user interfaces to allow outdoor and indoor users to access and manage information that is spatially registered with the real world. Outdoor users can experience spatialized multimedia presentations that are presented on a head-tracked, see-through, head-worn display used in conjunction with a hand-held pen-based computer. Indoor users can get an overview of the outdoor scene and communicate with outdoor users through a desktop user interface or a head- and hand-tracked immersive augmented reality user interface.     

Supporting Cooperation through Customisation: The Tviews Approach

User interfaces for groupware systems rarely reflectthe different requirements for support of theirend-users. Here we present an approach to designingmulti-user interfaces for cooperative systems whichbuilds on previous work from the HCI community in thearea of end-user customisation. Using this approach wehave developed an approach and a system prototype basedon tailorable views, or Tviews, which allows end-usersengaged in group working to configure theircooperative system interfaces to support theirdifferent tasks, preferences and levels of expertise.Tviews are user interface components which can bedragged and dropped over representations ofapplication objects to customise presentation,interaction and event updating properties, and canthemselves be tailored using high-level, incrementalcustomisation techniques. We discuss the implicationsof this work for CSCW system development by referenceto studies of work carried out by the CSCW communitywhich point to a need for more flexible and tailorablesystem interfaces.     

Using Distributable User Interfaces in CSCL In-Situ Classrooms

Distributable user interfaces enable users to distribute user interface interaction objects (i.e. panels, buttons, input fields, checkboxes, etc.) across different displays using a set of distribution primitives to manipulate them in real time. This work presents how this kind of user interfaces facilitates the computer supported collaborative learning in modern classrooms. These classrooms provide teachers and students with display ecosystems consisting of stationary displays, such as smart projectors and smart TVs as well as mobile displays owned by teachers and students, such as smartphones, tablets, and laptops. The distribution of user interface interaction objects enables teachers to modify the user interface interaction objects that are available to students in real time to control and promote the collaboration and participation among them during learning activities. We propose the development of this type of applications using an extension of the CAMELEON reference framework that supports the definition of UI distribution models. The Essay exercise is presented as a case of study where teachers control the collaboration among students by distributing user interface interaction objects.     

Usability levels for sparse linear algebra components

Sparse matrix computations are ubiquitous in high‐performance computing applications and often are their most computationally intensive part. In particular, efficient solution of large‐scale linear systems may drastically improve the overall application performance. Thus, the choice and implementation of the linear system solver are of paramount importance. It is difficult, however, to navigate through a multitude of available solver packages and to tune their performance to the problem at hand, mainly because of the plethora of interfaces, each requiring application adaptations to match the specifics of solver packages. For example, different ways of setting parameters and a variety of sparse matrix formats hinder smooth interactions of sparse matrix computations with user applications. In this paper, interfaces designed for components that encapsulate sparse matrix computations are discussed in the light of their matching with application usability requirements. Consequently, we distinguish three levels of interfaces, high, medium, and low, corresponding to the degree of user involvement in the linear system solution process and in sparse matrix manipulations. We demonstrate when each interface design choice is applicable and how it may be used to further users' scientific goals. Component computational overheads caused by various design choices are also examined, ranging from low level, for matrix manipulation components, to high level, in which a single component contains the entire linear system solver. Published in 2007 by John Wiley & Sons, Ltd.     

Application integration: Constructing composite applications from interactive components

Creating new applications by integrating user interface and application components is a relatively new idea which is currently of wide interest. A significant part of this problem is clearly defining the separation between user interface and application components. This paper proposes a new design methodology based on the concept of an abstract data view (ADV), a structuring method which cleanly defines this separation. A number of examples of composite interactive documents, ones which could contain several different user interfaces with entities such as text, calculations, drawings and possibly even multi-media presentations, illustrate the ADV concept. These examples lead naturally to the introduction of the concept of hole, a user interface area in a composite interactive document which is managed by an external program, and uses ADVs. Prototypes of a number of systems supporting ADVs and holes are currently running in our laboratory.     

From user interface design to the support of intelligent and adaptive interfaces: an overhaul of user interface software infrastracture

Research on adaptive interfaces in the past has lacked support from user interface tools which allow interfaces to be easily created and modified. Also, current user interface tools provide no support for user models which can collect task-oriented information about users. Developing an adaptive interface requires a user model and an adaptation strategy. It also, however, requires a user interface which can be adapted. The latter task is often time-consuming, especially in relation to more sophisticated user interfaces.

The paper presents a user interface design environment, UIDE, which has a different software infrastracture. Designers use high-level specifications to create a model of an application and links from the application to various interface components. The model is the heart of all the design and run-time support in UIDE, including automatic dialog sequencing and help generation. UIDE provides automatic support for collecting task-oriented information about users, by the use of its high-level specifications in its application model as a basic construct for a user model. Some examples of adaptive interfaces and adaptive help are presented that use the information that is collectable in UIDE.     

The effects of mice and pull‐down menus versus command‐driven interfaces on writing

The effects of two different computer user interfaces on the process of writing are examined. English composition students (matched on computer experience) used a computer and keyboard (either with function keys or with a mouse) to write essays during their English classes. Essays generated using either a mouse or command‐driven interface were compared across different stages of writing. The impact of using a mouse versus command‐driven interface is described by analyzing the differences in the process used to create the essays and the quality of the essays produced by each group. Results indicate that students who used the command‐driven interface scored better on organization of the paper, creativity, number of supporting arguments, grammar/spelling, and letter grade than did their mouse counterparts, as perceived by graders. However, there were no significant differences between the two interface conditions on any grammatical indices.     

Interactive design of 3D models with geometric constraints

In this paper, an interactive graphical approach for the design of parameterized part-hierarchies is presented. Primitive solids can be grouped into compound objects, and multiple instances of a compound object can be used in further designs. Geometric relations between primitives and instances are specified by geometric constraints between their local coordinate systems. The user can specify and edit a model by direct manipulation on a perspective or parallel projection with a mouse, whereas a procedural model representations is automatically generated via visual programming. The obtained twoview approach offers two concurrent interface styles to the end-user and enables the combination of an intuitive direct manipulation interface with the expressiveness of a procedural modeling language.     

On the interaction between plan recognition and intelligent interfaces

Plan recognition is an active research area in automatic reasoning, as well as a promising approach to engineering interfaces that can exploit models of user's plans and goals. Much research in the field has focused on the development of plan recognition algorithms to support particular user/system interactions, such as found in naturally occurring dialogues. However, two questions have typically remained unexamined: 1) exactly what kind of interface tasks can knowledge of a user's plans be used to support across communication modalities, and 2) how can such tasks in turn constrain development of plan recognition algorithms? In this paper we present a concrete exploration of these issues. In particular, we provide an assessment of plan recognition, with respect to the use of plan recognition in enhancing user interfaces. We clarify how use of a user model containing plans makes interfaces more intelligent and interactive (by providing an intelligent assistant that supports such tasks as advice generation, task completion, context-sensitive responses, error detection and recovery). We then show how interface tasks in turn provide constraints that must be satisfied in order for any plan recognizer to construct and represent a plan in ways that efficiently support these tasks. Finally, we survey how interfaces are fundamentally limited by current plan recognition approaches, and use these limitations to identify and motivate current research. Our research is developed in the context of CHECS, a plan-based design interface.     

The design of the user interface for a large physics experiment

The paper describes the experience in developing and supporting the user interface of RFX, one of the large nuclear fusion experiments of the co-ordinated nuclear fusion experiment programme of the European Community. The aim of this work is to present the problems and some possible solutions when developing user interfaces in a scientific environment, especially in large physics experiments. An overview of the current state of interface technology in such an environment is first provided. The control and data acquisition system of the RFX experiment is then introduced and its user interface described in greater detail. Finally, our experience both in maintaining the system interface and in training its users is described.