Model-driven approaches have been promoted for years. Despite their great interest, they remain hard to use in the context of user-centered design, especially when novel interaction techniques are expected. Thus, several research works [1][2][3] used a generative approach to build user interfaces -mainly skeletons to be completed -from task models. Following the analysis we made in [4], we can argue that this approach has several limitations:
• Generating requires the addition of information in order to reach an operative stage of interfaces. This information can be added to high-level models, which then loose their original goal; so doing they become hard to understand and to use, because of their multiple semantics (for example, adding presentation information to task models results in adding new semantics to this model). The other way is to insert this information during the generating process. This second approach is for example used in TERESA [5] by the way of heuristics, which are applied during the process. This however results in a lack of understanding of such transformations by users.
• All considered research issues are concerned with classical WIMP 1 applications. The hierarchical structure of task models is used to build the interface navigation scheme. We demonstrated in [4] that introducing non menu-based interactions implies a nonautomatic transformation of the dialogue. • Generating is not easy to include in iterative design cycles such as HCI-adapted cycles. When changes are required, it is necessary to modify the high-level models, and to generate again a new skeleton, to be improved again by hand-made add-ons. Some results have been obtained around the definition of "round-trip engineering" [6,7], but were not applied to HCI. More, this approach prevents the designers from starting from the prototype, which method is often used in post-WIMP design.
Our aim is to introduce a new way to use models in user interface design. Leaning on meta-models of one task model and one dialogue model, we wrote equivalence rules between such models. Then, we defined a new development cycle that can be used in a user-centered iterative approach.
In this paper, the context of the used models is first described. Then, an example of the meta-models is given, and equivalence rules are presented. In the third part, the proposed way to use these models in a development cycle is outlined.
The starting point of our work is the analysis from [4].
Whilst the generation appears to be too limitative, links between task models and user interfaces seem obvious. So, we decided to explore the possibility to establish strong links between task model and other models, and to consider exploiting said links in software design methods. For some reasons, which are external to our subject here, we chose the K-MAD model [8] as our task model.
In our laboratory, we have been working for some time on dialogue models and formal approaches in HCI. We introduced a software architecture model, H 4 , which was first dedicated to computer-aided systems. Coupled with that architectural model, we proposed a dialogue model, the hierarchical interactors [9], and developed tools to apply it [10]. Because of its hierarchical structure, the Hierarchical Interactor (HI) model appeared as the most suitable for our purpose. A previous study demonstrated the capacity to exploit these two models (K-MAD and HI) in HCI design [11].
Then, we defined the meta-model of these two models, which is published in [12]. We chose to use the EXPRESS language, an alternative to the OMG approach for meta-modeling. EXPRESS is a standard data modeling language for product data. It is formalized in the ISO Standard for the Exchange of Product model STEP (ISO 10303), and standardized as ISO 10303-11 2 . It is supported by complete verification tools, and allows a full expression of constraints [13].
In this section, we give a short description of the K-MAD and HI models, and provide some examples of the meta-models.
The K-MAD model is a hierarchical model where tasks are decomposed in sub-tasks, with temporal operators describing the dynamics of the model. The description can be enhanced by the definition of objects and expressions (preconditions, post-conditions, and actions) to control the model dynamics more precisely. The semantics of these different elements is defined in details.
Figure 1 illustrates a sample of the EXPRESS definition of the central element of the model, the task.
The HI model consists in a state machine model where the dialogue of the application is split into independent automata. Transitions are activated by tokens that represent user inputs or automaton productions.
The hierarchical organization of the model allows the automata to produce and consume tokens. The main advantages of this system are two-fold:
• Automata are independent from each other. They can be removed or added independently, without any change to others. • Tokens are the key elements of the model. As they can refer to both user entries and automaton productions, they break the binding between user inputs and 2 http://www.tc184-sc4.org/ transitions. This allows to consider the dialogue at the level of abstract level one wants. This is particularly important when post-WIMP interaction techniques are used.
The general philosophy of our approach is to take advantage of the hierarchical nature of the two models to establish strong associations between them.
The first obvious association can be made between tasks from the task model and transitions from the dialogue model. This link has been largely used in the previous research works, but for us, the link is not a bijective link: because of the need for interaction facilities in applications, there can be more transitions than user tasks.
The structure of the dialogue model encourages considering each task decomposition as equivalent to a specific automaton. The structure of the automaton must then be compatible with the dynamics described through the temporal operator of the compound task. Again, the dialogue may be richer than the simple translation of the temporal operator. Another consequence of this association is the equivalence between tokens and compound tasks: each compound task may be achieved by the way of an automaton that produces a token that stands for the task achievement.
The object/variable and expression associations
Both task model and dialogue model use expressions, which manipulate objects/variables. This link is patent, but was not described in the previous works because the used task model did not formally consider objects and expressions.
Two kinds of rules can be established between the models [12], based on the previously defined associations.
The first kind of rules concerns the existence of logically associated entities in both models. For example, are there one token and one automaton for each compound task? Or is there one transition in the dialogue model for each task in the task model?
The second kind of rules relates to the semantics of the models. Are the semantics of the expressions we can find in each model equivalent? Is the navigation, which is allowed by the automata, consistent with the temporal decomposition of the tasks?
These rules can be exploited in two ways. They can be used in initial design to generate a skeleton of the dialogue, or they can be used in verification to state that two models are compatible. In that way, our work might be compared to [14]. We describe in the next section the different usages of this duality.
In this section, we describe the global process we propose to utilize the modeldriven approach we describe above.
As previously claimed in the introduction, generating dialogue model from task models suffers from drawbacks; the most important of them is related to the iterative nature of usercentered approaches. When changes must be made in response to new or enhanced user needs, the generating process must be run again, and all handmade changes in the interface are lost. We argue that, if a generation phase occurs, it must be restricted to a starting point; then, the process must be able to achieve without any further generation.
The scenario schema we propose is as follows.
Assuming we are able to design, edit and verify each of both task and dialogue model. Each of these phases will be called "X-editing phase" thereafter. These phases may be realized independently from each other. Our model-driven approach consists in including these phases in a dynamic design process.
Optionally, one can start by a "task-editing phase", from which a starting skeleton for the dialogue model can be derived (e.g. generated, but only once). Either kinds of rules, existence rules and semantic rules, can be used to produce this skeleton. Then, the next phase consists in filling in the skeleton, in a "dialogue-editing phase". Adding specific dialogue elements, the dialogue model can be completed.
During this step, the two models can be confronted for detecting inconsistencies. By adding specific interaction elements to the skeleton, the designer might have changed the semantics of the model.
To reach this objective, the designer must associate the two models: some added dialogue entities might be related to task entities.
After analysis, depending on the result, different solutions can be applied:
• Fail. The two models do not match. Some tasks are missing in the dialogue model. The dialogue model must be improved to take into account the whole task model. • Fail. The two models do not match. The dynamics of the two models differ. The task model and/or the dialogue model must be modified. • Success. The two models match. The system is now ready to being tested by users.
A user evaluation phase may result in new requirements, which may lead us to coming back to either dialogue or task modeling, and resuming the loop.
In this paper, we present a global process to use a modeldriven approach in user interface design. This process uses rules that allow to check the validity of task models and dialogue models. Moreover, this process is compliant to user-centered approaches that promote iterative design.