Transparent migration and adaptation in a graphical user interface toolkit

The goal of this thesis is to enable the transparent migration and adaptation of graphical user interfaces (GUI). The migration of a GUI is the act of moving the GUI from one physical device to another. The adaptation of a GUI is the act of changing its presentation and/or behaviour while keeping usability. By transparency we mean that the migration and adaptation are specified separately from the GUI functionality and can be executed concurrently with the application. The thesis defines the EBL (Enhanced Binding Layer) framework, and a tool, EBL/Tk, built in this framework. EBL defines a binding between an existing graphical toolkit and a programming platform, the Mozart Programming System, resulting in an EBL-enabled toolkit. Each widget created by an EBL-enabled toolkit has a migration capability, which is a string that represents the authority to migrate the widget. Capabilities can be exchanged by EBL-enabled applications and used by container widgets to migrate widgets. Each widget also has an adaptation parameter. Different visual representations of the widget can be attached to specific values of this adaptation parameter. The application can change this value at runtime to trigger the change of representation, hence implementing the adaptation of the widget. EBL splits each widget into a logical component (the proxy) that is stationary at the application and a physical component (the renderer) that migrates to the display site. The communication between the proxy and the renderer is engineered to (1) facilitate the toolkit binding, (2) support migration for all widgets (including fault tolerance for Internet failures), (3) support adaptation for all widgets, (4) allow a mixed declarative/imperative approach to GUI programming, and (5) have a (limited) support for multi-user applications. The declarative/imperative approach greatly simplifies GUI development and makes it easy to define multiple renderers, which facilitates migration and adaptation. The use of an EBL-enabled toolkit does not have a negative impact on the cost of application development. The extra functionality is available as a conservative extension of a classical GUI toolkit. To validate EBL, a binding to the Tcl/Tk toolkit was created called EBL/Tk. This toolkit is available for download from the Dept. of Computing Science and Engineering at UCL.(FSA 3) -- UCL, 200

Migratable User Interfaces: Beyond Migratory User Interfaces

The migration of a user interface (UI) is the action of transferring a UI from a device to another one, for example from a desktop computer to a handheld device. A UI is said migratable if it has the migration ability. This paper describes how the QTk toolkit was extended to provide migratable UI and what API is 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 along. Also a window (stationary or migratable) may contain one or more receiver widgets: it is possible to dynamically compose a UI from several different UIs

Engineering the Transition of Interactive Collaborative Software from Cloud Computing to Edge Computing

The “Software as a Service” (SaaS) model of cloud computing popularized online multiuser collaborative software. Two famous examples of this class of software are Office 365 from Microsoft and Google Workspace. Cloud technology removes the need to install and update the software on end users’ computers and provides the necessary underlying infrastructure for online collaboration. However, to provide a good end-user experience, cloud services require an infrastructure able to scale up to the task and allow low-latency interactions with a variety of users worldwide. This is a limiting factor for actors that do not possess such infrastructure. Unlike cloud computing which forgets the computational and interactional capabilities of end users’ devices, the edge computing paradigm promises to exploit them as much as possible. To investigate the potential of edge computing over cloud computing, this paper presents a method for engineering interactive collaborative software supported by edge devices for the replacement of cloud computing resources. Our method is able to handle user interface aspects such as connection, execution, migration, and disconnection differently depending on the available technology. We exemplify our approach by developing a distributed Pictionary game deployed in two scenarios: a nonshared scenario where each participant interacts only with their own device and a shared scenario where participants also share a common device, including a TV. After a theoretical comparative study of edge vs. cloud computing, an experiment compares the two implementations to determine their effect on the end user’s perceived experience and latency vs. real latency

Towards Rapid Prototyping of Foldable Graphical User Interfaces with Flecto

Whilst new patents and announcements advertise the technical availability of foldable displays, which are capable to be folded to some extent, there is still a lack of fundamental and applied understanding of how to model, to design, and to prototype graphical user interfaces for these devices before actually implementing them. Without waiting for their off-the-shelf availability and without being tied to any physical foldable mechanism, Flecto defines a model, an associated notation, and supporting software for prototyping graphical user interfaces running on foldable displays, such as foldable smartphone or assemblies of foldable surfaces. For this purpose, we use an extended notation of the Yoshizawa-Randlett diagramming system, used to describe the folds of origami models, to characterize a foldable display and define possible interactive actions based on its folding operations. A guiding method for rapidly prototyping foldable user interfaces is devised and supported by Flecto, a design environment where foldable user interfaces are simulated in 3D environment instead of in physical reality. We report on a case study to demonstrate Flecto in action and we gather the feedback from users on Flecto, using Microsoft Product Reaction Cards

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. Keywords: Peer-to-peer, relaxed-ring, fault-tolerance, lookup consistency, ring maintenance. 1

Attach Me, Detach Me, Assemble Me Like You Work

Abstract. 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. Attaching 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.