Audrey Serna
email: audrey.serna@imag.fr

Gaëlle Calvary
email: gaelle.calvary@imag.fr

Dominique L Scapin
email: dominique.scapin@inria.fr

How Assessing Plasticity Design Choices Can Improve UI Quality: A Case Study

Keywords: Plasticity, UI design, quality in use. ACM classification H.5.2 User Interfaces: Evaluation/methodology

In Human Computer Interaction, plasticity refers to the capacity of User Interfaces (UIs) to withstand variations of context of use while preserving quality in use. Frequently, insuring more or less smooth transition from one context of use to the other (from the end-user perspective) is conducted ad hoc. To support a more systematic approach for characterizing UI tuning in terms of quality in use along context of use variations, we present an exploratory study focused deliberately on platform aspects. The design process of this particular case study is detailed and all design decisions have been recorded in terms of their influence on UI ergonomic quality, using Ergonomic Criteria. The interesting result is that most design choices when changing the platform lead to the reexamination of the initial designs. Ongoing work is done to support the insight that considering plasticity seems to help in explicitly broadening UI design choices and sharpening the solution.

INTRODUCTION

Plasticity is the ability of User Interfaces (UIs) to adapt to the context of use (<user, platform, environment>) while preserving quality in use [START_REF] Thevenin | Plasticity of User Interfaces: Framework and Research Agenda[END_REF]. Among the three keywords of the definition (adaptation, context of use, and quality), the most developed so far is UI adaptation. Adaptation may involve remolding and/or redistribution [START_REF] Balme | CAMELEON-RT: A Software Architecture Reference Model for Distributed, Migratable, and Plastic User Interfaces[END_REF]. Remolding transforms the UI without changing its distribution among the available interaction resources. On the contrary, redistribution changes the UI distribution and may require remolding to tailor the UI to the targeted context of use.

Remolding may occur at different levels of abstraction [START_REF] Allen | IPhone in action[END_REF] ranging from the task level to the concrete presentation.

From the designer's perspective, most of the time the focus is set on the platform dimension of the context of use ( [START_REF] Demeure | CamNote: A Plastic Slides Viewer[END_REF] and [START_REF] Grolaux | a Plastic Clock Written in Oz with the QTk toolkit[END_REF] for example). Regarding ergonomic quality, changing the platform is frequently considered at first sight as a set of constraints for the new UI. For example, remolding large-screen UIs for fitting small-screens is expected to result in an alteration of legibility and information density if the same information is provided similarly on both platforms. However, to our knowledge, no systematic approach has been followed to analyze the consequences of platform switches on ergonomic UI quality. Indeed, usability has been widely investigated (for example Ergonomic Criteria [START_REF] Scapin | Ergonomic criteria for evaluating the ergonomic quality of interactive systems[END_REF], QUIM [START_REF] Seffah | Usability and quality in use measurement and metrics: An integrative model[END_REF] or ISO standard [9]) for interactive systems, usually not integrating plasticity concepts. Nevertheless, little work has been conducted from a usability point of view, regarding the ergonomic UI quality during adaptation. [START_REF] Florins | Graceful Degradation: a Method for Designing Multiplatform Graphical User Interfaces[END_REF] elicits UI transformation rules for targeting a more constrained platform in terms of screen size for instance, but the quality of the source UI is not considered at all. On the contrary, [START_REF] Karampelas | Web User Interface Design Strategy: Designing for Device Independence[END_REF] recommends that a design strategy should achieve design independence by starting with the most limited device. [START_REF] Richter | Transformational consistency[END_REF] introduces transformational consistency among cross platform applications design. Providing immediate feedback helps the designer to overcome the trade-off between device optimization and cross device consistency. From the evaluation perspective, [START_REF] Gajos | Cross-Device Consistency in Automatically Generated User Interfaces[END_REF] presents a method to evaluate multi-device consistency. In addition to consistency issues, [START_REF] Calvary | A unifying reference framework for multi-target user interfaces[END_REF] addresses the problem of inter-usability of multi-device systems. The authors introduce design principles to maintain service continuity in inter-device transitions: inter-device consistency, transparency and dialogue adaptation. However, many other aspects of inter-usability are still not defined and no systematic approach is offered.

To step forward toward a more systematic method, the use of case studies can get rid of prejudices and support the basis of theoretical foundation. A first step in that direction consisted in characterizing, for one particular exploratory study, the evolution of ergonomic quality when designing an application with platform variations. We chose to focus voluntarily on platform aspects. Later on, the other changes in context of use (user and environment aspects) will need to be integrated in the analysis.

In this study, the perspective was to use existing useroriented metrics for observing UI quality evolution when switching platforms, through a kind of usability dashboard/ benchmark. Ergonomic Criteria are a support for inspecting and documenting evaluation of the ergonomic UIs quality [START_REF] Scapin | Ergonomic criteria for evaluating the ergonomic quality of interactive systems[END_REF]. The framework is structured along 18 elementary criteria that act as good predictors of UI quality (see for instance [2]). We chose to use this benchmark since it can be used for designing each version of the plastic UI, but using other inspection techniques would probably have, overall, resulted similarly, despite potential differences in problem coverage.

To sum up, this paper presents an exploratory case study for the design of a multi-platform e-government service. We describe the detailed design process, including the different iterations from one platform to another. For each iteration, the evolution of ergonomic quality is discussed according to the design choices made. Primarily results give an insight into how assessing plasticity design choices can improve the quality of UI. Ongoing and future works are presented to support this first step toward systematic means of assessing the consequences of plasticity on UI.

RUNNING the CASE STUDY Description

The case study concerns a service for students from vocational high schools. BRPE (acronym for "Regional Scholarship for First Equipment") is a governmental program to financially support students purchasing their equipment for technical courses (for instance, scissors set for hairdressing program). Until now, the application process was fully manual. At the beginning of the academic year, high school principals are in charge of informing students about the agenda and procedures for applying to the BRPE scholarship. They provide the paper form to applicants. For students under the age of majority, their parents or legal tutor are the ones allowed to fill the form. The forms and associated documents required (e.g. bank account statement) are given back to high school principals who are in charge of controlling the completeness of forms and sending the complete ones to the Regional Administration. Regional agents process the students' applications. If an application is accepted, the accounting department pays the scholarship through bank transfer to the bank account of the student (or his parents/tutor).

Global design process

Computerizing the process raises several issues:

• The form will have to be adapted: some part of the form may be dynamic (for example, the section concerning the student's age); other parts may disappear or be replaced by other ones (for example, the information confirmation by the high school principal).

• The emphasis must be on guiding students through the application process. Applying to BRPE must be easy and pleasant.

• The system must ensure observability of the application process and state. Students must be able to monitor their application progress whenever they want to. Offering to the user a view of the workflow in which his procedure is anchored is a key feature for e-services.

The study is focused on the students' part of the system. Figure 1 presents system specifications in terms of task models. The management of applications by regional agents is not described here.

Figure 1. BRPE task model for the e-service

The approach adopted here is a step-by-step development.

Based on the paper form, we first developed a version of BRPE for PCs, and then for iPhone. We call these steps "inter-platform iterations" (Figure 2). Inter-platform iteration consists in adapting UI from a source platform to a target platform. Each step of the iterative process was followed by an ergonomic inspection (performed by one or two experts on the Ergonomic Criteria benchmark). The ergonomic problems detected during these inspections led to iterations to improve the UI quality. Some of these problems implied only changes on the current platform prototypes. These changes are called "local iterations" (Figure 2). Those that question design decisions taken at an earlier step in the design process and require adjustments in the previous platform prototype are called "retro-iterations" (Figure 2).

A total of 8 iterations have been carried out for the multiplatform prototypes development: 4 iterations for PC and 4 for iPhone. In addition, 1 iteration for the paper form has been identified but not applied. Table 1 summarizes the different iterations.

Iterations 1, 2 and 3

The first three iterations deal with the development for PCs. As BRPE had never been computerized before, the first iteration had several ergonomic deficiencies. Two local iterations have been required to fix the identified problems.

Mainly four ergonomic criteria were found to be improved:

• Consistency: UI elements were too disparate and items homogenization was required. We proceeded with a classification of functional elements and a categorization of their aspects.

Figure 2. Design process with iterations between prototypes Table 1. Iterations summary

• Prompting: we observed a lack of guidance. A lot of administration terms had to be explained (for example what is the INE number, where can it be found, etc.) and the different guidelines to apply to a BRPE grant had to be added. Monitoring the progress of the student application was not very clear and had to be reconsidered.

• Legibility: some elements of the visual and graphic identity chosen for the UI were not convenient and disturbed legibility.

• Prevention against error: some important actions on the form (such as submit the application or erase the fields values) were not protected with confirmation dialog windows.

Iteration 2 allowed to fix most of these problems. Iteration 3 dealt with improving the monitoring part of the system.

At this stage of the process, we considered the ergonomic quality of the prototype for PC platform satisfactory enough to develop the iPhone prototype.

Iterations 4 and 5

For the inter-platform iteration 4, the major decision concerning the aspect of the UI was to favor the compatibility with iPhone web applications. We decided to use the pages layout and transitions common to iPhone web apps, which look like navigation lists [START_REF] Allen | IPhone in action[END_REF]. Figure 3 (b) represents the e-service home page for the first iPhone prototype (iteration 4). However, the decision to adopt the iPhone applications "look and feel" has adverse effects on:

• Consistency: the aspect of the prototype did not correspond to the aspect of the first prototype developed for the PC platform. One of the consequences is that switching from one platform to another, the user may be disoriented.

• Minimal actions: to access information, the user had to navigate constantly through several levels of list items, increasing the number of actions necessary to complete the task.

For iteration 5, we started over the prototype with the objective of using adapted visual and graphical styles from the PC platform. Figure 3 (c) presents the home page for the iPhone prototype in iteration 5. When compared to Figure 3 (a) illustrating the home page of the PC prototype, we can see that the look and feel of the PC prototype is respected. However some elements have been adapted to the target platform.

• Items aspects: the height, width, font size of elements is modified to suit the constraints links to the platform features (tactile interaction, screen size, etc.). For example, buttons are enlarged to be reachable with a finger. Items concerned: top-banner, links, buttons and dialog windows.

• Items layout: the spatial organization of elements is modified to fit the reduction in screen size. For example, on the application form, most of the text fields are presented line by line whereas in the PC prototype there can be 2 or 3 text fields on the same line. Items concerned: fields' layout in the form, buttons layout.

• Items labels: to fit the new aspect of some elements, their labels had to be shortened. For example, substantive form is used instead of a verb. In certain cases, the transformation may alter the quality of the label. In this case, we give priority to legibility on significance of codes. Items concerned: buttons label.

• Items behavior: the dynamic behavior of elements displaying additional information is adapted. To avoid multi-windows occurrence, the display is transformed into pages with a back button located at the top left of the page (to respect iPhone applications compatibility). Items concerned: tool-tip prompting and pop-up windows displaying optional information.

• User tasks: tasks that cannot be performed on the target platform are not presented on the UI. Prompting text replaces the task if this latter is mandatory for the completion of the global task. Items concerned: documents printing and visualization tasks. The ergonomic inspections of these two iterations showed dependencies between criteria. The design decisions made to favor such and such criterion can poorly influence other criteria. If the ergonomic quality is judged unsatisfactory, a local iteration can be conducted to find a trade off between the conflicting criteria. It is the case in Iteration 5, we chose to favor consistency and minimal actions criteria against compatibility (to iPhone web apps). In the same way, we favored legibility instead of significance of codes when needed.

Iteration 6

The prototype resulting from iteration 5 raised one major problem considering the application form. The form was displayed on a unique page. The user had to scroll to complete the form and to choose an action to carry out on that form, such as submitting the final application. In terms of ergonomic dimensions, the problematic criteria are:

• Information density: the form contains too much information to fit into the screen size while conserving legibility. As a result, the form is longer than the screen height and the user has to scroll to glance through the form.

• Prevention against error: The risk is that the user does not scroll and does not understand the form completion. In response to these problems, we chose to develop a stepped version of the application form (iteration 6). Figure 4 presents a page of the stepped form. Each field set identified in the previous prototype is broken up into small steps that fit into a page. To move into the form, navigation buttons ("<" to go to the previous step and ">" to go the next step) are added just after the fields. Quality in terms of information density and error protection increases, but decreases in terms of minimal actions. Indeed the navigation system increases the number of actions to complete the form. In addition, users loose the overview of the process. Here, we have a good example of dependencies between criteria and of the necessity of trade-off. We chose to keep the stepped form version and to favor error protection.

Iteration 7, 8 and 9

Iteration 6 raised two major problems with regard to the guidance dimension:

• Grouping / distinction between items by location for personal data form: when breaking up the personal data field set, we noticed that fields were not logically grouped. In consequence, some fields that should have appeared into the same page were located on different pages.

• Compatibility to task and Grouping / distinction between items by location and by format for actions buttons layout: in iteration 6, the action buttons were located in the last page of the application form. As a result, erasing fields values or saving the application process were not accessible at anytime anymore (problem in terms of compatibility to the task). Some of the actions buttons had to be displayed on each page of the stepped form. This issue leads to another problem. In the PC version, buttons were grouped according to the concept which they applied on: one group for the data captures concept (erasing fields value or canceling the data capture) and one group for the application concept (saving the data and submitting the application). The second group raises the problem of grouping and distinction between items. Indeed, saving the application process must be accessible at anytime in the stepped form whereas submitting the application can only be once the whole form is completed.

These problems reflect bad decisions in previous prototype design and imply a retro-iteration on the PC prototype (iteration 7). The changes made on the PC prototype have been then spread over the iPhone prototype (iteration 9). In more details, fields of the personal data form have been grouped according to small conceptual units. Figure 5 illustrates the evolution of the form design for both platforms among the iterations. These changes could be applied to the paper form in order to improve its quality. It would be a retro-iteration on paper form (iteration 8). We did not apply this iteration because redesigning the manual process was not part of our concern, this being under the authority of the administration.

Figure 6 illustrates the evolution of action buttons layout design for both platforms among the iterations. In the first iterations, buttons were grouped according to the concept on which they were operating. In iterations 7 and 9, buttons have been grouped according to accessibility of the buttons within the form. For the stepped version of the iPhone prototype, for erasing field values, canceling or saving the application, process buttons are available in each page of the stepped form whereas the submit button is only accessible on the last page of the form.

PRELIMINARY RESULTS AND FUTURE WORK

Looking for systematic means of assessing the consequences of plasticity on UI, from the end-user point of view, and to facilitate the designers' tasks is a complex question. Initially, the belief was that it would be possible to use currently available UI evaluation techniques (in our case, inspection using Ergonomic Criteria) for helping design, through a kind of usability dashboard/ benchmark. However, applying the approach to a case study clearly shows that before any systematic comparison of UI in different contexts (in our case, different platforms) one must make sure that all UIs are optimally designed (being aware there is no single solution). Considering the quality of the source UI is very important to clearly distinguish concerns between degradations (resp. beautifications) due to the change of platform versus evolutions triggered by the change of platform but feasible on the source platform. The side effect of this result is that designing plastic systems lead to improve the ergonomic quality on other platforms, simply because it facilitates the iterations among the various design solutions based on certain usability dimensions that may influence other usability dimensions. Also, this shows that among the set of potential solutions, some are some more easily transferable to other contexts of use.

This study is of course limited to the platform migration and to one particular e-government application. Further work will extend the approach to other context migrations (user and environment variations), and will be applied to other case studies. Efforts will be concentrated on building a method offering design guidance for developing plastic systems with respect to ergonomics. To improve guidance, we plan to develop tools for representing ergonomic inspection results for helping to visualize and quickly identify the weaknesses of one version and of the adaptation from one platform to another. This kind of tools could help, among others, designers and developers to choose the appropriate trade-off between different ergonomic dimensions. Finally, the method should be experimented by designers for validation perspectives.

Generalization of such exploratory studies may also be used to extract rules for adapting UI while preserving ergonomic quality. For example, to maintain prompting elements while preserving information density, minor information can be moved from the main page to an additional page with navigation between the two pages. Again, more case studies have to be investigated to extract and generalize such transformational rules. The perspective is to use these findings in model-driven engineering of plasticity and to integrate usability properties into model transformations as suggested in [START_REF] Lopez-Jaquero | A Seamless Development Process of Adaptive User Interfaces Explicitly Based on Usability Properties[END_REF][START_REF] Nilsson | Modelbased user interface adaptation[END_REF][START_REF] Sottet | A Model-Driven Engineering Approach for the Usability of Plastic User Interfaces[END_REF].

Iteration 0 Figure 3 .

 03 Figure 3. Home page of eBRPE through the different iterations (translated from French)

Figure 4 .

 4 Figure 4. Iteration 6 -Extract of the stepped form

Figure 5 .Figure 6 .

 56 Figure 5. The evolution of the "personal data" form among the iterations on both prototypes

ACKNOWLEDGMENTS

This work is supported by the french MyCitizSpace project (ANR 2007-2010). Special thanks to Florence Pontico for her help in mastering the BRPE case study.


Alfonso García Frey
email: alfonso.garcia-frey@imag.fr

Gaëlle Calvary

Sophie Dupuy-Chessa

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

Keywords: Self-Explanatory User Interfaces, UI quality, help, design rationale, model-driven engineering, model transformation. ACM Classification H.5.2 User Interfaces: Theory and method

Modern 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. Selfexplanation 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.

INTRODUCTION Problem Description

On the one hand, most software is too hard to use."Modern applications such as Microsft Word have many automatic features and hidden dependencies that are frequently helpful but can be mysterious to both novice and expert users" [START_REF] Myers | Answering why and why not questions in user interfaces[END_REF]. Users may require assistance while interacting with a User Interface (UI). Ideally, the UI must guide the user in accomplishing a task the application was designed for. The user can request help about functionality, features, or any information about the process of the task that is being performed.

The UI must be able to provide the correct answer, giving the necessary information to the user in an appropriate format. This can take place at any time in the whole interaction process between both the user and the UI. However, modern applications cover only a few questions the user may have, or provide a general help instead of a clear and concise answer to a given question. Furthermore, help is created ad-hoc, this is, it has been previously generated and it's not able to cover new questions at run-time because they were not considered by the designers. UI design problems are not covered at all because the designers are not aware of them.

Moreover, the UI must deal with users having different levels of expertise. Even many long-time users never master common procedures [START_REF] Corporation | Microsoft inductive user interface guidelines[END_REF] and in other cases, users must work hard to figure out each feature or screen [START_REF] Corporation | Microsoft inductive user interface guidelines[END_REF].

The problem is greater for Plastic UIs [START_REF] Collignon | Model-driven engineering of multi-target plastic user interfaces[END_REF][START_REF] Vanderdonckt | Multimodality for Plastic User Interfaces: Models, Methods, and Principles[END_REF]. In Human-Computer Interaction (HCI), plasticity refers to the ability of UIs to withstand variations of contexts of use while preserving usability. The adaptation of the UI has been addressed using many different approaches over the years, including Machine Learning [START_REF] Coutaz | An MDE-SOA approach to support plastic user interafces in ambient spaces[END_REF], Model-Driven Engineering (MDE) [START_REF] Sheshagiri | Using semantic web services for context-aware mobile applications[END_REF], and Component-oriented services [START_REF] Paulo | User interface declarative models and development environments : A survey[END_REF]. Regardless of the approach, the tendency has been to focus on functional aspects of adaptation, while neglecting the usability dimension. Plastic UIs demand dynamic adaptation also for help systems because from now on, developers can't afford to consider all the different contexts of use one by one coding all possible ad-hoc solutions by hand. This variety of contexts of use complicates the prediction of the result and the final quality, making the design choices difficult.

As a result, dynamic solutions are required also for help systems. These help systems must now be aware of the context of use (user, platform and environment), the task, the structure and presentation of the UI.

MDE and MB-UIDE approaches

On the other hand, Model-Driven Engineering (MDE) exists since long time ago and is recently applied to the engineering of UIs. It consists in describing different features of UIs (e.g., task, domain, context of use) in models from which a final UI is produced [START_REF] Vanderdonckt | Model-driven engineering of user interfaces: Promises, successes, failures, and challenges[END_REF] according to a forward engineering process. MDE of UI is assumed to be superior to the previous Model-Based User Interface Development Environment versions since it makes the UI design knowledge explicit, and external for instance as model-to-model transformations and model-to-code compilation rules [START_REF] Aquino | Adding flexibility in the model-driven engineering of user interfaces[END_REF]. However, whatever the apporach is (MDE or MB-UIDE), none of the automatically generated UI have enough quality, forcing designers to manually tweak the generated UI code [START_REF] Aquino | Adding flexibility in the model-driven engineering of user interfaces[END_REF]. Design knowledge can not be always explicitly represented into the models, but it has a potential to help users. Some of the models of the MDE approach as for instance the task model have this potential explicitly represented, and they can contribute also to guide and help the user.

Self-Explanatory User Interfaces

This paper focuses on an on-going research about Self-Explanatory User Interfaces (SE-UIs) by Model-Driven Engineering (MDE). Self-explanation makes reference to the capacity of a UI to provide the end-user with information about the rationale of the UI (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?).

In Figure 1 a message is displayed by request when the user asks information about the window in the background. SE-UIs aim to generate these answers dynamically, taking into account the current context of use in which the interaction between the end-user and the UI is taking place.

To accomplish this research we study how SE-UIs can be built by MDE. The MDE approach allows us to separate the different concerns of the UI in several levels of abstraction. The Cameleon Reference Framework [START_REF] Calvary | A unifying reference framework for multi-target user interfaces[END_REF] illustrates this process. Some models of MDE as for instance the task model have part of the design knowledge explicitly represented, and they can contribute also to guide and help the user.

In this paper we present two different aspects of our research. First, we explain a method to build SE-UIs using the MDE approach. In a second time, we propose an editor that implements this method in a visual way. The editor presented in this work is a prototype of the future editor we aim to build.

Even if some of the features are not available at the time of publishing this work, the general idea of the method and details about its implementation are provided in this paper.

RELATED WORK

Two major areas are involved in our Self-Explanation approach: MDE and UI quality. The next two sections set up the bases of our contribution regarding some of the related works in these fields.

MDE

The Cameleon Reference Framework [START_REF] Calvary | A unifying reference framework for multi-target user interfaces[END_REF] presented a MDEcompliant approach for developing UIs consisting of four different levels of abstraction: Task Model, Abstract User Interface, Concrete User Interface and Final User Interface. These levels correspond, in terms of MDE, to Computing-Independent Model (CIM), Platform-Independent Model (PIM), Platform-Specific Model (PSM) and the code level respectively. In the Model-Driven Development (MDD) many transformation engines for UI development have been created. Several researches have addressed the mapping problem for supporting MDD of UIs: Teresa [START_REF] Mori | Design and development of multidevice user interfaces through multiple logical descriptions[END_REF], ATL [START_REF] Jouault | Transforming models with atl[END_REF], oAW [START_REF] Jouault | Transforming models with atl[END_REF] and UsiXML [START_REF] Vanderdonckt | A MDA-Compliant environment for developing user interfaces of information systems[END_REF] among others. A comparative analysis can be found in [START_REF] González Calleros | A comparative analysis of tranformation engines for user interface development[END_REF]. Semantic Networks have been also covered for UIs [START_REF] Demeure | Towards run time plasticity control based on a semantic network[END_REF]. The Meta-UI concept was firstly proposed in [START_REF] Coutaz | Meta-user interfaces for ambient spaces[END_REF] and deeply explored later in many other works. In one of them [START_REF] Sottet | Megamodeling and Metamodel-Driven Engineering for Plastic User Interfaces: Mega-UI[END_REF], the concept of Mega-UI is studied introducing Extra-UIs, allowing a new degree of control by the use of views over the (meta-)models. We will focus on it later as these views are relevant for the explanation of the UI and consequently for the end-user's comprehension.

UIs Quality

Help systems have been extensively studied. One of the most relevant works is the Crystal application framework [START_REF] Myers | Answering why and why not questions in user interfaces[END_REF]. Inspired by the Whyline research [START_REF] Ko | Designing the whyline: a debugging interface for asking questions about program behavior[END_REF], "Crystal" provides an architecture and interaction techniques that allow programmers to create applications that let the user ask a wide variety of questions about why things did and did not happen, and how to use the related features of the application without using natural language [START_REF] Myers | Answering why and why not questions in user interfaces[END_REF]. Even if this approach does not cover the capacity of adaptation to different contexts of use, it represents an important improvement in quality for the end-user in terms of achieved value. Quality can be improved regarding not only the achieved value, but also from the perspectives of software features and interaction experiences [START_REF] Law | Maturing Usability. Quality in Software, Interaction and Value. Human-Computer Interaction Series[END_REF]. The integration of Usability Evaluation Methods (UEM) [START_REF] Law | Towards the maturation of IT usability evaluation (MAUSE)[END_REF] into a MDA process has been proved to be feasible in [START_REF] Abraho | Maturing Usability, chapter Usability Evaluation of User Interfaces Generated with a Model-Driven Architecture Tool[END_REF]. In particular, the evaluation at the PIM or PSM should be done in an interactive way until these models have the required level of usability. Different UEMs (e.g., heuristic evaluation, usability test, etc.) can be applied iteratively until the concerned models have the required level of usability. A set of ergonomic criteria for the evaluation of Human-Computer Interaction (HCI) can be found in [START_REF] Bastien | Ergonomic criteria for the evaluation of human-computer interfaces[END_REF].

Our research improves quality of help systems allowing a new range of questions. Adaptation to the context of use is now considered since SE-UIs understand their own rationale.

THE METHOD Basis

One of the ways to explore SE-UI involves the task model and its rationale. A task model describes the user's task in terms of objectives and procedures. Procedures recursively decompose tasks into subtasks until one or more elementary tasks are reached, i.e., tasks which would be decomposable into physical actions only ("press the button"). A task model is well-defined then by the following terms:

Nodes Containing abstract tasks

Leaves Special nodes containing elementary tasks Branches Expressing logical and temporal relations between tasks, subtasks and elementary tasks

The explicit information contained into the branches can help and guide the end-user answering questions related to different aspects of the UI. For instance, regarding the rationale of the UI questions like which is the purpose of the UI? can be successfully answered; also, questions as why is the UI structured into this set of workspaces? or what is the purpose of this button? can be explained understanding the relations of the design rationale. The current state of the UI and consequently the state of the application, can trigger a different kind of questions to the end-user as for instance why is the menu disabled?, as well as questions related to the overall progress of a task or questions about the evolution of the current state of the application as for example how can I enable this feature? Answers for all of them can be obtained exploring tasks and subtasks (nodes), elementary tasks (leaves) and relations between them (branches) in the task model. This research will consider also how different views of the model, in form of extra-UIs, can help the end-user to understand the UI. An extra-UI [START_REF] Sottet | Megamodeling and Metamodel-Driven Engineering for Plastic User Interfaces: Mega-UI[END_REF] is a UI which represents and gives the control of a UI through a model. These views can improve the end-user's comprehension as they are relevant for the explanation of the UI. Extra-UIs provide a new degree of control over the (meta-)models of the UI; both designer and end-user can see and understand how tasks are decomposed and represented in a specific UI. In other words, how the UI is interfacing the interaction between the application and the user. Designers can express this interaction in the form of relations between tasks and elements of the final UI with the method explained in the next section.

Four steps method

This work will explore a method to provide designers with a technique to add Self-Explanation to UIs specifying how end-user's tasks are directly related to the final UI level. The method consists in four steps:

1. Specify the final UI of the model-compliant application that it will be extended with SE functionality.

2. Define the task model of the application.

3. Specify the relations between both the task model and the final UI.

4.

A new final SE-UI will be generated from these relations, adding SE functionality in real-time.

The definition of the UI in the first step can be done considering several solutions. For this work, we use a specific file format definition in which a UI is expressed in a XML syntax-like. Other approaches and modalities can be considered as well.

For the second step we propose the use of the Concurrent Task Trees (CTT) notation to describe task models, which can specify a wide range of temporal relationships among tasks. CTT is a compact and graphical notation, immediate both to use and understand. Its logical structure makes it suitable for designing large sized applications even if, for the moment, we used a simplified version of the Concurrent Task Trees, which does not use the range of possible temporal operators.

Once we have specified the UI -by providing the specific file in our case-, and we have defined the task model of the associated application in the second step, we will link both of them in a third phase. Figure 2 shows an example of links between the given UI and the associated task model. Here, the task called Specify identity is visually connected to a group of widgets, containing two labels and two input fields. Then, the elementary task Specify first name which is also a sub- Once all the links are established we can generate a UI improved with SE-UI.

The main advantage of linking UIs with task models is that from now on, designers have no need of a deeply comprehension of all the model-to-model and model-to-code transformations between all the four levels of MDE approach.

A visual representation gives direct information about these relations because connections are explicitly represented in a visual render.

THE EDITOR

Xplain provides the designers with the ability to create SE-UI from a given a UI, by describing the task model of the associated application in a first step, then linking the states of this model to the desired components of the given UI, and finally generating a new UI based on the first one, but extended with SE functionality.

It is a graphical UI builder that allows designers to interactively specify all graphical aspects of an application, including both the widgets that go around the application windows, and the application-specific SE features as well. The designer can also specify the behaviors that these graphics exhibit creating relations between the widgets and the task graph model. From this information, Xplain generates help for the end-users.

As a first approach, help can be given with a help button. We can see an example inside the UI on the right side in figure 3.

Other approaches can be considered as well. By clicking this help button, the application enters in a help mode where the end-user can ask about different elements of the UI just by clicking on them. Answers will be generated in real-time in different ways. The following section illustrates an example of this procedure.

Answering questions

This work will study also how different questions can be answered. The first approach will associate a description to each element (tasks, relations, widgets, etc.) of figure 2. Other approaches like semantic networks [START_REF] Demeure | Towards run time plasticity control based on a semantic network[END_REF] can be considered in the future. If the end-user asks himself, for instance, Why is the OK button disabled?, by clicking on this button using the special help mode, the system can say that the task is not completed. In figure 1 the message is dynamically derived from the relations of figure 2. For an edit box, the application can say You must fill in + Description of the task,where your personal information is the description. A more specific information can be generated exploring the task model. For instance, we can check all the subtasks of the uncompleted task. In the example before, we can answer also that the user needs to fill in the first name and the last name, because these subtasks are both uncompleted.

Example of Use

In Figure 3 we can see the prototype in use. The designer has opened a .ui file that contains the specification of the UI in a XML-like syntax. This .ui format comes from the Qt development framework. Other formats should be also supported in the future. Once the designer opens the file, Xplain parses the contained data and the UI is rendered inside the workspace. In the right side of the editor, the designer has a panel showing different tools to create task models. At the moment of this publication the CTT notation is not supported and the designer can just express nodes and links between these nodes as we can see in Figure 3. To create the graph, the designer can select the circle in the panel on the right and draw as many nodes as necessary into the workspace. Each time the designer creates a node, a pop-up message will ask him a description. The designer can then enter an associated description for this node and continue building new nodes. This description will be used later as an explanation for the associated widget. In other words, the description of a node is the description of the task represented by this node.

Once the task model is defined, the designer can pick up the linker tool in the toolbar on the top of the window and link with the mouse all the nodes with all the widgets of the UI. Different widgets can be grouped also under the same task.

The designer can link more than one widget with the same node, grouping content by tasks.

Finally, the designer can press the green arrow at the right of the toolbar to generate a completely new UI enhanced with Self Explanation. As explained before, a little help button is added to the new window in order to let the user ask about the UI.

This new UI is running into the workspace and the designer can enter data, use the new button to test the new functionality, and test other properties of the UI without the need of an external tool to recompile the generated ui file.

The prototype has been coded in C++ using the Qt framework.

WORK IN PROGRESS AND FUTURE WORK

This prototype brings out some questions for SE-UIs:

1. Can complementary views of the UI help us to guide the end-user?

2. How and in which manner?

3. Which part or parts of the MDE approach need to be visible to the end-user? 4. Which is the best way to collect information from the enduser about the encountered problems while performing a task?

Questions one to three can be addressed also to the designers. Due to these questions we continue to develop the state of the art. For example, we are also exploring different ways to let the user ask about the UI and how to deal with the possible answers.

Other further work is to take into account all the UsiXML models. This will help us not only with plasticity but also with modality, allowing us to create more sophisticated SE-UIs.

The prototype does not support models at the moment and the designer must create the associated graphs by hand. The integration of the models as well as the CTT notation for the task model is a priority for the near future.

CONCLUSION

This research aims at improving the quality of UIs. It explores MDE of UIs to provide Self-Explanation at run-time, taking benefit from the four levels of abstraction and their relationships.

A prototype of the SE-UI editor is being developed to support designers. This prototype implements a four steps method that takes a UI in input and generates the associated SE-UI in output. The designer can interact with the generated SE-UI directly inside Xplain. This prototype lets different questions open that motivate our research in different ways.

Finally complementary views of the UI needs to be explored in order to exploit the models of the MDE approach, explaining the UI itself and giving to the user a new dimension of control by these views. This opens the work on End-User programming.

Figure 1 .

 1 Figure 1. A help message leads the user through the UI.

Figure 2 .

 2 Figure 2. Association between UI and a task model.

Figure 3 .

 3 Figure 3. A Self-Explanatory UI is generated on the right side from the links on the left side.

ACKNOWLEDGMENTS

This work is funded by the european ITEA UsiXML project.


Alfonso García Frey
email: alfonso.garcia-frey@imag.fr

Gaëlle Calvary
email: gaelle.calvary@imag.fr

Sophie Dupuy-Chessa
email: sophie.dupuy@imag.fr

Self-Explanatory User Interfaces by Model-Driven Engineering

Keywords: Self-Explanatory User Interfaces, UI quality, help, design rationale, model-driven engineering, model transformation. ACM Classification H.5.2 User Interfaces: Theory and method

Modern 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 context of use. The complexity does not necessarily imply a better quality. Thus, it becomes necessary to make users understand the UIs. This paper describes an on-going research about Self-Explanatory User Interfaces (SE-UI) by Model-Driven Engineering (MDE). 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. We explore modeldriven engineering to understand why and how this approach can lead us to overcome shortcomings of UI quality successfully.

INTRODUCTION Motivation

On the one hand, most software is too hard to use."Modern applications such as Microsft Word have many automatic features and hidden dependencies that are frequently helpful but can be mysterious to both novice and expert users" [START_REF] Myers | Answering why and why not questions in user interfaces[END_REF]. Users may require assistance while interacting with a User Interface (UI). Ideally, the UI must guide the user in accomplishing a task the application was designed for. The user can request help about functionality, features, or any information about the process of the task that is being performed. The UI must be able to provide the correct answer, giving the necessary information to the user in an appropiate format. This can take place at any time in the whole interaction process between both the user and the UI. However, modern applications cover only a few questions the user may have, or provide a general help instead of a clear and concise answer to a given question. Furthermore, help is created ad-hoc, this is, it has been previously generated and it's not able to cover new questions at run-time because they were not considered by the designers. UI design problems are not covered at all because the designers are not aware of them.

Moreover, the UI must deal with users having different levels of expertise. Even many long-time users never master common procedures [START_REF] Corporation | Microsoft inductive user interface guidelines[END_REF] and in other cases, users must work hard to figure out each feature or screen [START_REF] Corporation | Microsoft inductive user interface guidelines[END_REF].

The problem is greater for Plastic UIs [START_REF] Collignon | Model-driven engineering of multi-target plastic user interfaces[END_REF][START_REF] Vanderdonckt | Multimodality for Plastic User Interfaces: Models, Methods, and Principles[END_REF]. Plastic UIs demand dynamic adaptation also for help systems because from now on, developers can't afford to consider all the different contexts of use one by one coding all possible ad-hoc solutions by hand. This complicates the prediction of the result and the final quality, making difficult the design choices.

As a result, dynamic solutions are required also for help systems. These help systems must now be aware of the context of use (user, platform and environment), the task, the structure and presentation of the UI.

MDE and MB-UIDE approaches

On the other hand, Model-Driven Engineering (MDE) exists since long time ago and its recently applied to the engineering of UIs. It consists in describing different features of UIs (e.g., task, domain, context of use) in models from which a final UI is produced [START_REF] Vanderdonckt | Model-driven engineering of user interfaces: Promises, successes, failures, and challenges[END_REF] according to a forward engineering process. MDE of UI is assumed to be superior to the previous Model-Based User Interface Development Environment versions since it makes the UI design knowledge explicit, and external for instance as model-to-model transformations and model-to-code compilation rules [START_REF] Aquino | Adding flexibility in the model-driven engineering of user interfaces[END_REF]. However, neither Model-Based User Interface Development Environment automatic generated UIs nor final UIs produced by MDE have enough quality, forcing designers to manually tweak the generated UI code [START_REF] Aquino | Adding flexibility in the model-driven engineering of user interfaces[END_REF]. Design knowledge can not be always explicitly represented into the models, but it has a potential to help final users. Some models as for instance the task model have this potential explicitly represented, and they can contribute also to guide and help the user. This research will study how Self-Explanatory User Interfaces (SE-UIs) can be built using the MDE. A SE-UI is a UI with the capacity of understanding its own rationale and consequently having the abilities of answer questions about it. We aim to provide a method for creating SE-UIs analyzing the relations between the different levels of abstraction in our MDE-compliant approach for developing UIs as well as the different models presented into the UsiXML specification and their relations. Complementary views of the UI are also considered into this research.

The rest of the paper presents the related work and our contribution to the field.

RELATED WORK

The two major areas involved in our Self-Explanation approach are MDE and UI quality. The related works of the next two sections allow us to set up the bases of our contribution.

MDE

The Cameleon Reference Framework [START_REF] Calvary | A unifying reference framework for multi-target user interfaces[END_REF] presented a MDEcompliant approach for developing UIs consisting of four different levels of abstraction: Task Model, Abstract User Interface, Concrete User Interface and Final User Interface. These levels correspond, in terms of MDE, to Computing-Independent Model (CIM), Platform-Independent Model (PIM), Platform-Specific Model (PSM) and the code level respectively. In the Model-Driven Development (MDD) many transformation engines for UI development have been created. Several researches have addressed the mapping problem for supporting MDD of UIs: Teresa [START_REF] Mori | Design and development of multidevice user interfaces through multiple logical descriptions[END_REF], ATL [START_REF] Jouault | Transforming models with atl[END_REF], oAW [START_REF] Jouault | Transforming models with atl[END_REF] and UsiXML [START_REF] Vanderdonckt | A MDA-Compliant environment for developing user interfaces of information systems[END_REF] among others. A comparative analysis can be found in [START_REF] González Calleros | A comparative analysis of tranformation engines for user interface development[END_REF]. Semantic Networks have been also covered for UIs [START_REF] Demeure | Towards run time plasticity control based on a semantic network[END_REF]. The Meta-UI concept was firstly proposed in [START_REF] Coutaz | Meta-user interfaces for ambient spaces[END_REF] and deeply explored later in many other works. In one of them [START_REF] Sottet | Megamodeling and Metamodel-Driven Engineering for Plastic User Interfaces: Mega-UI[END_REF], the concept of Mega-UI is studied introducing Extra-UIs, allowing a new degree of control by the use of views over the (meta-)models. We will focus on it later as these views are relevant for the explanation of the UI and consequently for the end-user's comprehension.

UIs Quality

Help systems have been extensively studied. One of the most relevant works is the Crystal application framework [START_REF] Myers | Answering why and why not questions in user interfaces[END_REF]. Inspired by the Whyline research [START_REF] Ko | Designing the whyline: a debugging interface for asking questions about program behavior[END_REF], "Crystal" provides an architecture and interaction techniques that allow programmers to create applications that let the user ask a wide variety of questions about why things did and did not happen, and how to use the related features of the application without using natural language [START_REF] Myers | Answering why and why not questions in user interfaces[END_REF]. Even if this approach does not cover the capacity of adaptation to different contexts of use, it represents an important improvement in quality for the end-user in terms of achieved value. Quality can be improved regarding not only the achieved value, but also from the perspectives of software features and interaction experiences [START_REF] Law | Maturing Usability. Quality in Software, Interaction and Value. Human-Computer Interaction Series[END_REF]. The integration of Usability Evaluation Methods (UEM) [START_REF] Law | Towards the maturation of IT usability evaluation (MAUSE)[END_REF] into a MDA process has been proved to be feasible in [START_REF] Abraho | Maturing Usability, chapter Usability Evaluation of User Interfaces Generated with a Model-Driven Architecture Tool[END_REF]. In particular, the evaluation at the PIM or PSM should be done in an interactive way until these models have the required level of usability. Different UEMs (e.g., heuristic evaluation, usability test, etc) can be applied iteratively until the concerned models have the required level of usability. A set of ergonomic criteria for the evaluation of Human-Computer Interaction (HCI) can be found in [START_REF] Bastien | Ergonomic criteria for the evaluation of human-computer interfaces[END_REF].

This research improves quality of help systems allowing a new range of questions. Adaptation to the context of use is now considered since SE-UIs understand their own rationale.

CONTRIBUTION End-User's point of view

The goal of this work is to study how SE-UI can be built by MDE. One of the ways to explore SE-UI involves the task model and its rationale. A task model describes the user's task in terms of objectives and procedures. Procedures recursively decompose tasks into subtasks until one or more elementary tasks are reached, i.e., tasks which would be decomposable into physical actions only ("press the button"). A task model is well-defined then by the following terms:

Nodes Containing abstract tasks

Leaves Special nodes containing elementary tasks Branches Expressing logical and temporal relations between tasks, subtasks and elementary tasks

The explicit information contained into the branches can help and guide the end-user answering questions related to different aspects of the UI. For instance, regarding the rationale of the UI questions like which is the purpose of the UI? can be successfully answered; also, questions as why is the UI structured into this set of workspaces? or what is the purpose of this button? can be explained understanding the relations of the design rationale. The current state of the UI and consequently the state of the application, can trigger a different kind of questions to the end-user as for instance why is the menu disabled?, as well as questions related to the overall progress of a task or questions about the evolution of the current state of the application as for example how can I enable this feature? Answers for all of them can be obtained exploring tasks and subtasks (nodes), elementary tasks (leaves) and relations between them (branches) in the task model.

This work will study also how different views of the model centered in extra-UIs, can help the end-user to understand the UI. A extra-UI [START_REF] Sottet | Megamodeling and Metamodel-Driven Engineering for Plastic User Interfaces: Mega-UI[END_REF] is a UI which represents and gives the control of a UI through a model. It is in a sense the UI of the configuration of a UI. These views can improve the enduser's comprehension as they are relevant for the explanation of the UI. Extra-UIs provide a new degree of control over the (meta-)models of the UI; both designer and end-user can see and understand how tasks are decomposed and how tasks are represented in a specific UI. In other words, how the UI is interfacing the interaction between the application and the own user. Designers can express this interaction in the form of relations between tasks and elements of the final UI with the method explained in the next section.

Designer's point of view

This work will explore a method to provide designers with a technique to add Self-Explanation to final UIs, specifying how end-user's tasks are directly related to the final UI level. The method consists in four steps:

1. Specify the final UI of the model-compliant application that it will be extended with SE functionality.

2. Define the task model of the application.

3. Specify the relations between both the task model and the final UI.

4.

A new final SE-UI will be generated from these relations, adding SE functionality in real-time.

To support this method, we will supply designers with an editor in which tasks models and final UIs can be created. Both of them will coexist at the same time into the same workspace inside this editor. Once the task model and the final UI are represented, the designer will draw direct connections between elements of the task model and elements of the final UI, linking for instance, widgets with subtasks, as we can see in figure 1. Here, the task called Specify identity is visually connected to a group of widgets, containing two labels and two input fields. Then, the elementary task Specify first name which is also a subtask, is connected to a new subgroup of two widgets, one label and one input field. The purpose of the method is to allow designers to specify direct relations between tasks and different elements of the final UI. The main advantage for designers is that from now on, there is no need of a deeply comprehension of all the model-to-model and model-to-code transformations between all the four levels of MDE. A visual representation gives direct information about these relations because connections are explicitly represented in a visual render, in which the final UI and the task model levels share the same workspace.

To allow end-user questions this study will consider a help button (figure 2) as a first approach. Other approaches can be considered as well. By clicking this help button, the application enters in a help mode where the end-user can ask about different elements of the UI just by clicking on them. Answers will be generated in real-time in different ways. The following section illustrates an example of this procedure.

Answering questions

This work will study also how different questions can be answered. The first approach will associate a description to each element (tasks, relations, widgets, etc.) of figure 1. Other approaches like semantic networks [START_REF] Demeure | Towards run time plasticity control based on a semantic network[END_REF] can be considered in the future. If the end-user asks himself, for instance, Why is the OK button disabled?, by clicking on this button using the special help mode, the system can say that the task is not completed. In figure 2 the message is dynamically derived from the relations of figure 1. For an edit box, the application can say You must fill in + Description of the task, where your personal information is the description. A more specific information can be generated exploring the task model. For instance, we can travel all the subtasks of the uncompleted task. In the example before, we can answer also that the user needs to fill in the first name and the last name, because these subtasks are both uncompleted.

CONCLUSION

This research takes a significant step forward in the development of high quality UIs. It explores MDE of UIs to provide Self-Explanation at run-time, analysing the four levels of the MDE-compliant approach for developing UIs and the different models presented into the UsiXML specification and their relations. Complementary views of the UI are explored in order to exploit these models, explaining the UI itself and giving to the user a new dimension of control by these views. This opens the work on End-User programming.

Figure 1 .

 1 Figure 1. Association between UI and a task model.

Figure 2 .

 2 Figure 2. Help message derived from connections in Figure 1.

ACKNOWLEDGMENTS

This work is funded by the european ITEA UsiXML project.


Ambient Intelligence: Science or Fad?

1.1. Ambient intelligence: still young at 20 years Ambient intelligence concerns the use of emerging technologies for computing, sensing, displaying, communicating, and interacting to provide services in ordinary human environments. Different facets of this problem have been addressed under a variety of names, including ubiquitous computing, pervasive computing, disappearing computing, and internet of things. Whatever the name, the field is defined by its core aim: to provide services and devices that can adapt to individuals' needs and the social context. This includes diverse applications such as aiding people to adopt more energy-efficient lifestyles, improving the quality of life for the disabled, helping senior citizens remain independent, and aiding families with services for security, entertainment, and with tools for managing the cost of living. Ambient intelligence is not a new concept. In 1988, only a few years after the introduction of the Macintosh computer and the French Minitel, Mark Weiser [WEI 91] identified the principal challenges under the name "ubiquitous computing". Weiser stated that technologies centered around daily activities would inevitably fade from view while becoming an imperceptible but ubiquitous component of ordinary life. Weiser contended that, although increasingly widespread, personal computing was the first of many steps in this process.

During 1990s, researchers at IBM proposed the term pervasive computing. With this approach, emphasis was placed on technical challenges such as developing hardware and software techniques necessary for bringing computing into ordinary Chapter written by Joëlle COUTAZ and James L. CROWLEY.

human environments. At around the same time, the European IST Advisory Group (ISTAG) put forth its vision of ambient intelligence [STA 03], leading to the creation of the Disappearing Computer program within the European Union's Fifth Framework Programme for Research and Technological Development. This period also saw the emergence of the Philips Research "Vision of the Future" [PHI 96] program and the creation of the Philips HomeLab designed to stimulate creativity through experimentation, to explore new opportunities for combining different technologies, to identify the socio-cultural significance of these innovations, and to make these concepts tangible, useful, and accessible to all.

During this period, a number of conferences, workshops, and journals were organized. The Ubicomp 1 conference, created from the mobile computing and smart environment communities, focuses primarily on user experience. The IEEE Pervasive and Percom 2 conferences have arisen from the "distributed computing" community, to focus on the challenges and technical solutions in distributed systems and networks. Within Europe, the EUSAI (European Symposium on Ambient Intelligence), later renamed AmI -Ambient Intelligence 3 , was launched in 2002 with support from Philips Research. A scientific community has also emerged to address the topic of context-aware computing. While the concept of context is not new in computer science (nor in other fields), bringing computing into ordinary human environments raises a rich, new set of problems. Other aspects of this problem have also been explored, including collectives of artificial agents for ambient intelligence 4 , the internet of things 5 and Machine-to-Machine (M2M), communicating objects, mobile computing, wearable computing 6 , social computing, intelligent habitats and environments (towns, housing, roads, transport, architecture, etc.), tangible and embedded interaction 7 , affective computing, human-robot interaction 8 , and embedded systems.

In summary, Weiser's vision has been used to justify and define new research within an extremely diverse collection of fields. It is increasingly evident that such research cannot be carried out in isolation. Research in this area is fundamentally multi-disciplinary, requiring the assimilation of problems and concepts from a variety of specializations. From our perspective, in its current state, ambient intelligence is only the latest stage in the evolution of informatics as a scientific discipline. In the following chapters, we will provide an overview of the field in its current state.

A step forward in the evolution of informatics

Waldner [WAL 07] has summarized the evolution of computing by charting the continual miniaturization of electronic components, the spectacular increase in information processing and memory capacity, the omnipresence of networks, and the reduced costs of hardware production. In this approach, development of resources drives changes in the nature of computing. We carry out a parallel analysis using the changes in resources to predict developments in research. We will focus on three areas in particular: the availability of computing power as a critical resource, the individual as the focus of attention, and the physical and social worlds in relation to the digital world.

Fifty years ago: the computer as an isolated critical resource

Fifty years ago, computing machines were far too expensive and it was cumbersome to even imagine them being used in everyday homes, as shown in Figure 1.1. Access to computing was restricted to specialist operators and programs were carefully encoded on perforated "punch cards". Computing results were printed on reams of special fan-folded paper, with punch cards, magnetic tapes, and removable disks used for long-term storage. At best, computing machines had around a megabyte of central memory. Computing networks and packet switching technologies for communications were an avant-garde area of research 9 .

During this period, the user was a programmer specialized in scientific computing, statistics, and management applications (such as payroll). Programs were entered by a dedicated operator, who monitored the use of resources using a specific control language (Job Control Language, JCL). Any program that consumed more memory or printed more pages than what was anticipated was automatically terminated by the operating system and the programmer was responsible for declaring the required computing resources. The skill lay in being able to produce a correct program "from the start" using such techniques as memory overlays so that the program ran using the available central memory. The concept of virtual memory therefore became a subject of research. With the emergence of timesharing systems, punching cards gradually disappeared in favor of personal terminals. These were initially built using TELEX terminals or "teletypes" that were eventually replaced by alphanumerical screens. Bit-mapped displays; however, were judged far too expensive because of memory costs. 9 Louis Pouzin, then a researcher at IRIA (later the INRIA), and his team were responsible for the invention of packet-switching communications. Their data-gramme technique was used within the Cyclade project, with a first network composed of hubs at IRIA, the CII, and the IMAG in France. The first demonstration took place in 1973.

Figure 1.1. a) A computer for all, the IBM 360, carrying out batch processing (at night) and time sharing (by day). b) A box of cards consisting of what can only be described as a very real program! The program's procedures are given by lines and names written in pencil. c) The Cyclade hub at IMAG (Grenoble, France)

The optimization of resources and "virtualization" (found today in cloud computing) remained the driving force in computing until researchers (North American, for the most part) turned their attention to the human component of the human-machine system. Indeed, as the cost of computing machines decreased, labor costs increasingly dominated the cost of computing.

Thirty years ago: the user at the center of design

The first CHI (Computer-Human Interaction) conference of the ACM10 was organized in 1983. This conference, parallel with the first appearance of personal computers, marked the start of the pursuit of developing useful and usable applications for users. The user was no longer an experienced programmer, but a non-specialist using the computer as a tool for professional activities. An application was considered useful if it provided the functions expected by its user where it was said to ensure "functional conformity". A program was considered usable if the user interface (UI), which gives access to applicative functions, conformed to the cognitive, motor, and sensory capabilities of the target user. This is known as "interactional conformity".

Computer scientists, whether academic or industrial, have, for too long, underestimated the cognitive dimension of the human user. Not only should a program provide her/him with the expected functions, but it should also provide access to these functions in a manner that respects the user's working procedures and abilities to perceive and reason. Not only should this arrangement conform to human thought processes, but it should also be made explicit to the user interface. It was only in 2010 that computing professionals recognized that the design of the human-computer interface was not simply a question of aesthetics, but an issue of user-computer conformity. By contributing concepts, theories, and methods, cognitive psychology and ergonomics have played an important role in addressing this problem. Two complementary representations compete in modern user interface technologies: linguistic representations (including natural and artificial languages, as in the Unix Shell), and metaphorical interfaces based on the real world, such as with the desktop environment in modern personal computers. The WIMP (Window, Icon, Menu, Pointing) interaction paradigm, made possible by modern user interface toolkits, is a modern manifestation of the impact of the direct correspondence principle and its theoretical foundation in the Model Human Processor.

Ergonomics and cognitive psychology have also had a major impact on evaluation methods by suggesting protocols and metrics to assess human performance such as task performance duration and error rates. Although these methods are well elaborated and documented, in practice software developers are still reluctant to integrate them into the software development process or, if they do so, evaluation is performed too late in the development process to have a real impact on system usability.

At the same time, the Internet, wireless networks, the web (which celebrated its 20th year in 2010), and web browsers are now used by nearly everyone. From a single computer, we have passed on to an era of "instantly connected" computing.

The past decade: combining physical, social, and digital worlds

In contrast to the previous era of computing, in which the desktop computer was the archetype, new technologies increasingly enable mobility and integration of digital systems into the ordinary physical objects. Ordinary objects are increasingly being fitted with technologies for computing, communications, sensing, actuation, and interaction. These devices are increasingly networked, forming a complex infrastructure creating a plethora of new services. Figure 1.3 demonstrates this trend in four images.

The examples in Figure 1.3 lead to three immediate observations: the polymorphism of the computer that weaves, both literally and figuratively, the digital into our everyday activities, from the useful to the pointless. In other words, the physical world has become a resource that can be shaped and (re)constructed by the individual, not only to be more efficient but also to improve the quality of our life, pleasure, and experiences. This has resulted in the emergence of "funology" (i.e. the science of having fun) [BLY 06]. The user is no longer a subject limited to "consuming" applications imposed by the market, but can now take on the role of actor such as "DIYers" who construct and improve their living space using off-theshelf components. Even the individual's ability to create has itself been surpassed by a new phenomenon, social networking [KRA 10], made possible by the universality of the Internet.

Figure 1.3. Examples of services and devices: a) a light projection on a floor; b) the "history tablecloth" [GAV 06] that traces the movement of objects on it with a glowing ring gradually forming around the object and then progressively disappearing when the object is moved; c) an Arduino LilyPad application: personalization of a jacket fitted with an indicator showing changes in direction [BUE 08]; d) siftables that can be assembled in different ways to create new applications [MER 07]

The social dimension of computing has in fact been an area of interest since the end of the 1980s11 . The initial aim was to develop models, theories, and digital systems, called groupware, designed to improve group activities in terms of production, coordination, and communication. With the web, the change in scale has led to new uses. Every individual, collective, and community can now collect information, relate it, produce new information, and in turn share it with the rest of the world. Schneiderman [SHN 98] refers to this phenomenon with the mantra collect-relate-create-donate. Wikipedia is the most obvious example of a collective construction of encyclopedic knowledge. Other examples include the Google Image Labeler, which indexes images and TopCoder for thesocial production programs. The digital software stores, inspired by the Apple App Store, have led to changes in the software development process and have triggered new economic models and opportunities.

Figure 1.4. Examples of devices integrating new ICT capabilities, device nanotechnology. a) A Gummi prototype (Sony), a bendable computer. Navigation across the screen is achieved by bending the surface [SCH 04]. b) A bendable OLED screen (introduced by Sony to the SID, Society for Information Display, 2010). c) Skinput applied to a music device: the finger pressure applied to the surface skin is sensed by an armband fitted with sensors [HAR 10]. d) A soft lens fitted with a circuit is placed directly on the surface of the eye

Despite the constant avalanche of information, the human factor remains constant. The user remains a genuine bottleneck, and requires the invention of new interaction techniques to accommodate a growing flood of information. In this sense, gestural interaction and inertial measurement units in mobile telephones, physical interaction and motion sensing devices using real time 3D reconstruction such as Microsoft's Kinect muscular interaction, multipoint clear screens, and bendable objects are all noteworthy examples, as illustrated in Figure 1.4. These examples show that innovation requires the unprecedented cooperation ICT (information and communication technologies) and ICT-HSS (human and social sciences), from nanotechnologies to software engineering, and from the individual to all levels of society.

This brief overview indicates that we are entering into an era of radical change, which, in turn, raises a number of new challenges.

Extreme challenges

The scientific, technical, and ethical challenges posed by ambient intelligence have been examined by a number of reports [COU 08, STA 03, PUN 05, WAL 07], specialized journals, conference sessions, and workshops. Research problems are generally organized as a stack of sub-domains shown in Figure 1.5. Three key challenges facing the field cover all of these domains: scalability, heterogeneity, and dynamic adaptation. These three challenges arise from the fact that ambient intelligence pushes computing to its limits.

Multi-scale

Changes in scale can lead to unexpected phenomena. For ambient intelligence, the challenge of scale results from the massive interconnection of a very large number of ordinary devices augmented with computing, sensing, actuation, and interaction. The challenge lies in managing the co-existence of services and systems made possible by the interconnection of devices over a wide range of scales, from personal body-area networks based on wearable computing to city-wide and planetary scale systems. This challenge is greatly complicated by the heterogeneity resulting in part from technical challenges at each scale.

Heterogeneity

At any scale, a variety of possible solutions may be used to address competing technical challenges. In addition, each scale raises its own unique challenges.

Integrating devices with different programming frameworks can prove extremely complex. Integrating across scales makes integration even more challenging. While the field has seen concerted movements toward uniform standards, too often such efforts have been carried out in a vacuum, resulting in isolated silos of interoperability. In such environments, dynamic adaptation is therefore impossible.

Dynamic adaptation

Dynamic adaptation, with its multiple facets, approaches, and solutions has been examined for over a number of years in a variety of fields and research specialties (see Figure 1.5). For some researchers, the ultimate aim is an autonomous, safe, and secure system that does not require human intervention. For others, however, the user should remain involved if desired. It is therefore necessary that "autonomous software compositions" provide users with interaction points at every level of abstraction in order to control the adaptation process if needed. These problems have only been addressed in a piecemeal manner to date, constrained by the restricted view of a single specialty or area of application. It is therefore necessary to develop new technologies that are generic, enabling, and malleable. These technologies should be generic so that they can be applied to all contexts and allow the rapid development of services by professionals. Malleability is needed so that they can be organized and changed by the end user, as required, in a non-uniform, constrained, dynamic, and multi-scale world12 . This is not a question of creating a uniform and standardized world, but respecting diversity and the unexpected. For our part, the "malleable" constitutes a major challenge in coming years because we are placing the means to program (unconsciously), develop programs (without endangering life or property), and share them with others (like the App Store over social networks) in the hands of the end user.

Conclusion

In view of the above, is ambient intelligence a fad or an emerging scientific discipline? In line with Thomas Kuhn's definition, our analysis suggests that ambient intelligence does not have the status of a discipline13 yet. If a scientific community is said to be organized around symposia and specialized reviews, it does not necessarily entail sharing a standard set of concepts and methods. Ambient intelligence is still "application driven" for its socio-economic benefits.

For the foreseeable future, we believe that the response will be a progressive evolution of research processes and a collaborative approach toward a concrete and lasting integrated strategy. Indeed, each discipline and specialty progress by sharing information with other disciplines (it is a multi-disciplinary alliance that drives "collaborative" research projects) or new shared knowledge will arise from the integration of several disciplines and specialties, a pluri-disciplinary convergence, which is a challenge in itself. Human-machine interaction is a perfect example of the convergence between psychology, sociology, and computing. However, it has taken more than 20 years for it to be recognized as a discipline in its own right. It is therefore a question of time. Nevertheless, let us remember Alan Kay's well-known quote, "the best way to predict the future is to invent it!".

  Methods used for user-interface design include participative and contextual design [BEY 06], iterative design (which is well adapted to the practice of "agile" programming), and scenario-based design [ROS 02]. These user-focused methods have given rise to a number of formalisms such as CLG [CAR 83], TAG [PAY 86] and ETAG [TAU 90], UAN [HAR 92], and CTT [PAT 97] to model the thought processes of target users in the form of task models (a tree structure with aims and sub-aims linked by composition operators or temporal relations). Such models go beyond a simple Use Case UML, to specify the functional requirements and task sequences from a user perspective.Example theories include the Model Human Processor [CAR 83] and Norman's direct correspondence principle [NOR 86], which state that there should be a clear correspondence between the psychological variables encountered by the user mentally and computing objects, as well as a direct correspondence between the internal state of the system in relation to the user and its representation by the user interface. These theories are, or at least should be, part of the toolkit of any competent computer scientist.

Figure 1 . 2 .

 12 Figure 1.2. In search of a graphic representation of the desktop metaphor, an idea already being used in the 1970s: sketch produced by Tim Mott at the end of the 1970s (taken from [MOG 06], p. 52). It shows the first generic commands: "Print, File, Delete, Mail, Cut and Paste, Grab and Move"

Figure 1 . 5 .

 15 Figure 1.5. Architectural overview of research themes in ambient intelligence

Comment [SN2]: AU : Should « Philips Research » read « Philips research's »

Comment [SN3]: AU : Should « data-gramme » in footnote 9 read « datagramme ».

Comment [E4]: Palpable doesn't really fit this context

CHI'83 followed the first workshop on the subject in Gaithersburg in March 1982, entitled Human Factors in Computer Systems. Comment [E5]: Thought plans doesn't provide much meaning here. Comment [CE6]: AU : Please check "[BEY 06]" has not been listed in Bibliography.

Comment [CE7]: AU : Please check "[BLY 06]" has not been listed in Bibliography.

The first ACM conference on the subject Computer Supported Collaborative Work (CSCW) took place in 1987.

What Bell and Dourish call, in less technical terms, a messy fragmented world [BEL 06].

www.electroniques.biz/pdf/EIH200312110541038.pdf (in French).

Comment [CE8]: AU: Please provide volume number and page range. Comment [SN9]: AU : Please provide the volume number.