Chris Vandervelpen

Dygimes: Dynamically Generating Interfaces for Mobile Computing Devices and Embedded Systems

Constructing multi-device interfaces still presents major challenges, despite all efforts of the industry and several academic initiatives to develop usable solutions. One approach which is finding its way into general use, is XML-based User Interface descriptions to generate suitable User Interfaces for embedded systems and mobile computing devices. Another important solution is Model-based User Interface design, which evolved into a very suitable but academic approach for designing multi-device interfaces. We introduce a framework, Dygimes, which uses XML-based User Interface descriptions in combination with selected models, to generate User Interfaces for different kinds of devices at runtime. With this framework task specifications are combined with XML-based User Interface building blocks to generate User Interfaces that can adapt to the context of use. The design of the User Interface and the implementation of the application code can be separated, while smooth integration of the functionality and the User Interface is supported. The resulting interface is location independent: it can migrate over devices while invoking functionality using standard protocols.

Light-Weight distributed web interfaces: preparing the web for heterogeneous environments

In this paper we show an approach that allows web interfaces to be dynamically distributed among several interconnected heterogeneous devices in an environment to support the tasks and activities the user performs. The approach uses a light-weight HTTP-based daemon as a distribution manager and RelaxNG schemas to describe the service user interfaces offered by native applications. From these service descriptions, the XHTML-based user interface is generated.

Designing distributed user interfaces for ambient intelligent environments using models and simulations

Abstract There is a growing demand for design support to create interactive systems that are deployed in ambient intelligent environments. Unlike traditional interactive systems, the wide diversity of situations these type of user interfaces need to work in require tool support that is close to the environment of the end-user on the one hand and provide a smooth integration with the application logic on the other hand. This paper shows how the model-based user interface development methodology can be applied for ambient intelligent environments; we propose a task-centered approach towards the design of interactive systems by means of appropriate visualizations and simulations of different models. Besides the use of these typical user interface models such as the task- and presentation-model to support interface design, we focus on user interfaces supporting situated task distributions and a visualization of context influences on deployed, possibly distributed, user interfaces. To enable this we introduce an environment model describing the device configuration at particular moment in time. To support the user interface designer while creating these complex interfaces for ambient intelligent environments, we discuss tool support using a visualization of the environment together with simulations of the user interface configurations. We also show how the concepts presented in the paper can be integrated within model-driven engineering, hereby narrowing the gap between HCI design and software engineering.

Migratable User Interface Descriptions in Component-Based Development

In this paper we describe how a component-based approach can be combined with a user interface (UI) description language to get more flexible and adaptable UIs for embedded systems and mobile computing devices. We envision a new approach for building adaptable user interfaces for embedded systems, which can migrate from one device to another. Adaptability to the device constraints is especially important for adding reusability and extensibility to UIs for embedded systems: this way they are ready to keep pace with new technologies.

A task-driven user interface architecture for ambient intelligent environments

This paper presents a modular runtime architecture supporting our model-based user interface design approach for designing context-aware, distributable user interfaces for ambient intelligent environments.

Task-Based Design and Runtime Support for Multimodal User Interface Distribution

This paper describes an approach that uses task modelling for the development of distributed and multimodal user interfaces. We propose to enrich tasks with possible interaction modalities in order to allow the user to perform these tasks using an appropriate modality. The information of the augmented task model can then be used in a generic runtime architecture we have extended to support runtime decisions for distributing the user interface among several devices based on the specified interaction modalities. The approach was tested in the implementation of several case studies. One of these will be presented in this paper to clarify the approach.

Task modeling for ambient intelligent environments: design support for situated task executions

The design of interactive systems for an ambient intelligent environment poses many challenges because of the great diversity in devices the user has control of and the users situation imposed by the environment. Although task-centered interface design is an established approach for traditional form-based and even for multi-device user interfaces, this design approach is, in its current form, not ready for the design of user interfaces for ambient intelligent environments. In this paper we propose a task-centered approach to design interaction mechanisms for ambient intelligent environments by means of visualization and simulation. We focus on three different concepts that are important to support this approach: situated task allocations, user interface distributions and visualization of context influences. Because the execution of a task depends strongly on the situation or context of use, the consequences of a context change on the execution of a task specification should be communicated with the task designer during the design process. The designer should be able to define the possibilities to execute a task while taking into account constraints imposed by the environment of the user. A tool to support this approach using visualization of the environment and simulation of the interface configurations is introduced.

A prototype-driven development process for context-aware user interfaces

This paper describes a model-based development process for context-aware user interfaces. The development process consists of the specification and updates of several models followed by the generation and evaluation of a prototype. A generic runtime architecture will be presented supporting distinct prototyping renderers at different abstraction levels in order to support prototyped development during the whole design cycle of the context-aware user interface. To clarify the functioning of the architecture, a case study will be presented, demonstrating the possibilities of this prototype-driven development approach.