Donatien Grolaux

A toolkit for peer-to-peer distributed user interfaces: concepts, implementation, and applications

In this paper we present a software toolkit for deploying peer-to-peer distributed graphical user interfaces across four dimensions: multiple displays, multiple platforms, multiple operating systems, and multiple users, either independently or concurrently. This toolkit is based on the concept of multi-purpose proxy connected to one or many rendering engines in order to render a graphical user interface in part or whole for any user, any operating system (Linux, Mac OS X and Windows XP or higher), any computing platform (ranging from a pocket PC to a wall screen), and/or any display (ranging from private to public displays). This toolkit is a genuine peer-to-peer solution in that no computing platform is used for a server or for a client: any user interface can be distributed across users, systems, and platforms independently of their location, system constraints, and platform constraints. After defining the toolkit concepts, its implementation is described, motivated, and exemplified on two non-form based user interfaces: a distributed office automation and a distributed interactive game.

Attach me, detach me, assemble me like you work

Detachable user interfaces consist of graphical user interfaces whose parts or whole can be detached at run-time from their host, migrated onto another computing platform while carrying out the task, possibly adapted to the new platform and attached to the target platform in a peer-to-peer fashion. Detaching is the property of splitting a part of a UI for transferring it onto another platform. AttAaching is the reciprocal property: a part of an existing interface can be attached to the currently being used interface so as to recompose another one on-demand, according to user’s needs, task requirements. Assembling interface parts by detaching and attaching allows dynamically composing, decomposing and re-composing new interfaces on demand. To support this interaction paradigm, a development infrastructure has been developed based on a series of primitives such as display, undisplay, copy, expose, return, transfer, delegate, and switch. We exemplify it with QTkDraw, a painting application with attaching and detaching based on the development infrastructure.

Migratable user interfaces: beyond migratory interfaces

The migration of a user interface (UI) is the action of transferring a UI from one device to another, for example from a desktop computer to a handheld device. A UI is said to be migratable if it has the ability to migrate. This paper describes how the QTk toolkit has been extended to provide a migratable UI and the application programming interface (API) provided to the developers. Basically, an indirection layer has been introduced between the application and the actual representation of the UI. The migration of a UI is achieved by firstly creating a clone of the state of the site displaying the UI, secondly by changing the indirection to point to this clone. The API provides a way to specify if (the entirety of) a window can be migrated or not at construction time. A migratable window returns a universal reference that can be given to any site with whom a network connection is possible. This reference can be used by a receiver widget to migrate the window there. Interestingly, a migratable window can itself contain a receiver widget configured to display the content of another migratable window: all windows are transparently migrated. Also a window (stationary or migratable) may contain one or more receiver widgets : it is possible to dynamically compose a Ul from several different UIs.

QTk - A Mixed Declarative/Procedural Approach for Designing Executable User Interfaces

When designing executable user interfaces, it is often advantageous to use declarative and procedural approaches together, each when most appropriate: - A declarative approach can be used to define widget types, their initial states, their resize behavior, and how they are nested to form each window. All this information can be represented as a data structure. For example, widgets can be records and the window structure is then simply a nested record. - A procedural approach can be used when its expressive power is needed, i.e., to define most of the UI’s dynamic behavior. For example, UI events trigger calls to action procedures and the application can change widget state by invoking handler objects. Both action procedures and handler objects can be embedded in the data structures used by the declarative approach.

Overcoming the multiplicity of languages and technologies for web-based development using a multi-paradigm approach

In this paper, we present QHTML, a library for building Web-based applications in Oz. QHTML provides the Oz programmer with a basic set of abstractions through which creating Web-based interfaces becomes similar to traditional graphical toolkits. In the mean time, QHTML is an experiment investigating whether a single language can replace the numerous ad-hoc combined languages/technologies currently used for building Web-based interfaces. QHTML is realized thanks to the multi-paradigm features of the Oz programming language, which supports symbolic data structures, a functional programming style, an object-oriented style and concurrency via dataflow and lightweightthreads.

Automated Repair Tool for Usability and Accessibility of Web Sites

The need for checking both usability and accessibility of Web sites is widely recognized, approved and recommended by several official organizations. What should really be more recognized or addressed is an equal need for repairing the usability and accessibility defects that have been detected. Within the Destine suite, we developed a tool allowing to repair the HTML source code of a page with user interaction. Thanks to an improved version of the Guideline Definition Language (GDL), the accessibility guidelines are not hard-coded, so that our tool can deal with any existing or future standards

A fault tolerant abstraction for transparent distributed programming

This paper introduces a network fault model for distributed applications developed with the Mozart programming platform. First, it describes the fault model currently offered by Mozart, and the issues that make this model inconvenient for building fault-tolerant applications. Second, it introduces a novel fault model that addresses these issues. This model is based on a localization operation for distributed entities, and on an event-based mechanism to manage network faults. We claim that this model 1) is much better than the current one in all aspects, and 2) simplifies the development of fault-tolerant distributed applications by making the fault-tolerant aspect (largely) separate from the application logic. A prototype of this model has been developed on the existing Mozart platform. This prototype has been used on real applications to validate the aforementioned claims.

Improving the Peer-to-Peer Ring for Building Fault-Tolerant Grids

Peer-to-peer networks are gaining popularity in order to build Grid systems. Among different approaches, structured overlay networks using ring topology are the most preferred ones. However, one of the main problems of peer-to-peer rings is to guarantee lookup consistency in presence of multiple joins, leaves and failures nodes. Since lookup consistency and fault-tolerance are crucial properties for building Grids or any application, these issues cannot be avoided. We introduce a novel relaxed-ring architecture for fault-tolerant and cost-efficient ring maintenance. Limitations related to failure handling are formally identified, providing strong guarantees to develop applications on top of the relaxed-ring architecture. Besides permanent failures, the paper analyses temporary failures and broken links, which are often ignored.

PEPINO: PEer-to-Peer network INspectOr

PEPINO is a simple and effective peer-to-peer network inspector. It visualises not only meaningful pointers and connections between peers, but also the exchange of messages between them, providing a useful tool for debugging purposes. It can monitor running networks, simulate them and log them in order to reproduce interesting case scenarios. Failures can be explicitly introduced to study fault tolerant algorithms. The graphical representation of the network uses a physical model to attract or repel peers, allowing the user to study the system from different points of view. This demo aims to present the use of PEPINO in the development of a novel relaxed-ring topology for fault tolerant networks, where the representation of the ring based on predecessors may differ from the ring based on successors. We show how PEPINO is also useful for visualising other network topologies such as perfect ring or unstructured networks.