Self-Explanatory User Interfaces by Model-Driven Engineering

International audienceModern User Interfaces (UI) must deal with the increasing complexity of applications as well as new features such as the capacity of UIs to be dynamically adapted to the con- text of use. The complexity does not necessarily imply a better quality. Thus, it becomes necessary to make users un- derstand the UIs. This paper describes an on-going research about Self-Explanatory User Interfaces (SE-UI) by Model- Driven Engineering (MDE). Self-explanation makes refer- ence to the capacity of a UI to provide the end-user with information about its rationale (which is the purpose of the UI), its design rationale (why is the UI structured into this set of workspaces?, what's the purpose of this button?), its current state (why is the menu disabled?) as well as the evo- lution of the state (how can I enable this feature?). Explana- tions are provided by embedded models. We explore model- driven engineering to understand why and how this approach can lead us to overcome shortcomings of UI quality success- fully

Self-Explanatory User Interfaces by Model-Driven Engineering

International audienceModern User Interfaces (UI) must deal with the increasing complexity of applications as well as new features such as the capacity of UIs to be dynamically adapted to the con- text of use. The complexity does not necessarily imply a better quality. Thus, it becomes necessary to make users un- derstand the UIs. This paper describes an on-going research about Self-Explanatory User Interfaces (SE-UI) by Model- Driven Engineering (MDE). Self-explanation makes refer- ence to the capacity of a UI to provide the end-user with information about its rationale (which is the purpose of the UI), its design rationale (why is the UI structured into this set of workspaces?, what's the purpose of this button?), its current state (why is the menu disabled?) as well as the evo- lution of the state (how can I enable this feature?). Explana- tions are provided by embedded models. We explore model- driven engineering to understand why and how this approach can lead us to overcome shortcomings of UI quality success- fully

Xplain: an Editor for building Self-Explanatory User Interfaces by Model-Driven Engineering

International audienceModern User Interfaces (UI) must deal with the increasing complexity of applications in terms of functionality as well as new properties as plasticity. The plasticity of a UI denotes its capacity of adaptation to the context of use while preserving its quality. The efforts in plasticity have focused on the (meta) modeling of the UI, but the quality remains uncovered. This paper describes an on-going research that studies a method to develop Self-Explanatory User Interfaces as well as an editor that implements this method. Self-explanation makes reference to the capacity of a UI to provide the end-user with information about its rationale (which is the purpose of the UI), its design rationale (why is the UI structured into this set of workspaces?, what's the purpose of this button?), its current state (why is the menu disabled?) as well as the evolution of the state (how can I enable this feature?). Explanations are provided by embedded models

Quality of Human-Computer Interaction : Self-Explanatory User Interfaces by Model-Driven Engineering

In Human-Computer Interaction, quality is an utopia. Despite all the design efforts, there are always uses and situations for which the user interface is not perfect. This thesis investigates self-explanatory user interfaces for improving the quality perceived by end users. The approach follows the principles of model-driven engineering. It consists in keeping the design models at runtime so that to dynamically enrich the user interface with a set of possible questions and answers. The questions are related to usage (for instance, "What's the purpose of this button?", "Why is this action not possible"?) as well as to design rationale (for instance, "Why are the items not alphabetically ordered?"). This thesis proposes a software infrastructure UsiExplain based on the UsiXML metamodels. An evaluation conducted on a case study related to a car shopping webiste confirms that the approach is relevant especially for usage questions. Design rationale will be further explored in the future.STAREn Interaction Homme-Machine, la qualité est une utopie : malgré toutes les précautions prises en conception, il existe toujours des utilisateurs et des situations d'usage pour lesquels l'Interface Homme-Machine (IHM) est imparfaite. Cette thèse explore l'auto-explication des IHM pour améliorer la qualité perçue par les utilisateurs. L'approche s'inscrit dans une Ingénierie Dirigée par les Modèles. Elle consiste à embarquer à l'exécution les modèles de conception pour dynamiquement augmenter l'IHM d'un ensemble de questions et de réponses. Les questions peuvent être relatives à l'utilisation de l'IHM (par exemple, "A quoi sert ce bouton ?", "Pourquoi telle action n'est pas possible ?) et à sa justification (par exemple, "Pourquoi les items ne sont-ils pas rangés par ordre alphabétique ?"). Cette thèse propose une infrastructure logicielle UsiExplain basée sur les méta-modèles UsiXML. L'évaluation sur un cas d'étude d'achat de voitures montre que l'approche est pertinente pour les questions d'utilisation de l'IHM. Elle ouvre des perspectives en justification de conception

Don’t Throw your Software Prototypes Away. Reuse them!

The mechanism of prototype development is considered by the research and industrial software communities as a key tool for user-developer communication. In software development, prototypes are used in requirements engineering to help elicit and validate users’ needs. Software prototypes like mockups are frequently considered throwaway artefacts and therefore they are often developed very fast, or with very few resources and discarded. In this paper we propose to change this idea, and to create prototypes that can be reused in any model-driven engineering (MDE) process. The paper presents an approach for an automatic mechanism for translating prototype models into requirements models and its implementation in a suitable tool case. This way, software developer teams will be able to dedicate resources to improving communication with users using prototypes because the knowledge acquired will be automatically transferred to the requirements phase of the development process

Cedar Studio: an IDE supporting adaptive model-driven user interfaces for enterprise applications

Support tools are necessary for the adoption of model-driven engineering of adaptive user interfaces (UI). Enterprise applications in particular, require a tool that could be used by developers as well as I.T. personnel during all the development and post-development phases. An IDE that supports adaptive model-driven enterprise UIs could further promote the adoption of this approach. This paper describes Cedar Studio, our IDE for building adaptive model-driven UIs based on the CEDAR reference architecture for adaptive UIs. This IDE provides visual design and code editing tools for UI models and adaptive behavior. It is evaluated conceptually using a set of criteria from the literature and applied practically by devising example adaptive enterprise user interfaces

Adaptive model-driven user interface development systems

Adaptive user interfaces (UIs) were introduced to address some of the usability problems that plague many software applications. Model-driven engineering formed the basis for most of the systems targeting the development of such UIs. An overview of these systems is presented and a set of criteria is established to evaluate the strengths and shortcomings of the state-of-the-art, which is categorized under architectures, techniques, and tools. A summary of the evaluation is presented in tables that visually illustrate the fulfillment of each criterion by each system. The evaluation identified several gaps in the existing art and highlighted the areas of promising improvement

Engineering Adaptive Model-Driven User Interfaces

Software applications that are very large-scale, can encompass hundreds of complex user interfaces (UIs). Such applications are commonly sold as feature-bloated off-the-shelf products to be used by people with variable needs in the required features and layout preferences. Although many UI adaptation approaches were proposed, several gaps and limitations including: extensibility and integration in legacy systems, still need to be addressed in the state-of-the-art adaptive UI development systems. This paper presents Role-Based UI Simplification (RBUIS) as a mechanism for increasing usability through adaptive behaviour by providing end-users with a minimal feature-set and an optimal layout, based on the context-of- use. RBUIS uses an interpreted runtime model-driven approach based on the Cedar Architecture, and is supported by the integrated development environment (IDE), Cedar Studio. RBUIS was evaluated by integrating it into OFBiz, an open-source ERP system. The integration method was assessed and measured by establishing and applying technical metrics. Afterwards, a usability study was carried out to evaluate whether UIs simplified with RBUIS show an improvement over their initial counterparts. This study leveraged questionnaires, checking task completion times and output quality, and eye-tracking. The results showed that UIs simplified with RBUIS significantly improve end-user efficiency, effectiveness, and perceived usability

Engineering Adaptive Model-Driven User Interfaces for Enterprise Applications

Enterprise applications such as enterprise resource planning systems have numerous complex user interfaces (UIs). Usability problems plague these UIs because they are offered as a generic off-the-shelf solution to end-users with diverse needs in terms of their required features and layout preferences. Adaptive UIs can help in improving usability by tailoring the features and layout based on the context-of-use. The model-driven UI development approach offers the possibility of applying different types of adaptations on the various UI levels of abstraction. This approach forms the basis for many works researching the development of adaptive UIs. Yet, several gaps were identified in the state-of-the-art adaptive model-driven UI development systems. To fill these gaps, this thesis presents an approach that offers the following novel contributions: - The Cedar Architecture serves as a reference for developing adaptive model-driven enterprise application user interfaces. - Role-Based User Interface Simplification (RBUIS) is a mechanism for improving usability through adaptive behavior, by providing end-users with a minimal feature-set and an optimal layout based on the context-of-use. - Cedar Studio is an integrated development environment, which provides tool support for building adaptive model-driven enterprise application UIs using RBUIS based on the Cedar Architecture. The contributions were evaluated from the technical and human perspectives. Several metrics were established and applied to measure the technical characteristics of the proposed approach after integrating it into an open-source enterprise application. Additional insights about the approach were obtained through the opinions of industry experts and data from real-life projects. Usability studies showed the approach’s ability to significantly improve usability in terms of end-user efficiency, effectiveness and satisfaction

Self-explanatory user interfaces by model-driven engineering.

International audienceModern User Interfaces (UI) must deal with the increasing complexity of applications in terms of functionality as well as new properties as plasticity. The plasticity of a UI denotes its capacity of adaptation to the context of use preserving its quality. The efforts in plasticity have focused on the (meta) modeling of the UI, but the quality remains uncovered. We suggest a method for improving the quality of the UIs by providing explanations about the design of the UI itself: this is, by the use of the Self-Explanation. Self-Explanatory User Interfaces (SEUI) makes reference to the capacity of a UI to supply the end-user with all the information on the rational of the UI, about its constitution (for example, what is the purpose of this button?), its current state (why is the menu disabled?) as well as its evolution (how can I enable this feature?)