User Interface Modeling and Software Engineering Concepts

This section briefly discusses model-based user interface development approaches from the viewpoint of Software Engineering and MDE as relevant for this work. The relationship to Software Engineer- ing concepts and standards (see section3.4) are indeed discussed and often mentioned as one of the important challenges, like in [Clerckx et al.04] or in group discussions like [Basnyat et al.05]. Compliance

Considering Software Engineering concepts can be performed on two levels: First, the user interface must be linked to the the application logic. Provided that the application logic is developed using models as well, it is useful to enable links between these models. Many approaches do already fulfill these requirement by including an application model into their approach. Of course, it is useful to

enable compliance with application models in Software Engineering by either using UML, as the de-facto standard in Software Engineering, or by enabling flexible usage of any application model. Second, it can be useful to adhere to Software Engineering standards in general, as they are subject of intensive research and well established. This enables reuse of general concepts and tools and might also increase the general acceptance of an approach.

Several contributions discuss the integration of user interface modeling and UML. Standard UML does not explicitly support user interface modeling concepts. For example, there is no kind of abstract user interface element. Of course, on implementation level a widget is just an ordinary class and can thus be specified in an ordinary UML class diagram. However, its semantics then would not differ from any other application class, which would not be useful for meaningful user interface modeling. Modeling the dialogue is easier with UML as behavior diagrams like State Charts can be used for this purpose. Finally, the tasks, as one of the central user interface modeling concepts, are not explicitly supported in UML but it is subject of several discussions (e.g. [Trætteberg02, Paternò01]) whether they can be substituted by existing UML elements with similar semantics. On a first look, UML Use Cases seem similar to tasks as they specify the actions a system can perform when interacting with the user. However, Use Cases focus on system when interacting with one or multiple actors while task models focus on the individual user and his goals [Paternò99, Markopoulos and Marijnissen00, Con- stantine and Lockwood01]. Another possibility is to substitute tasks by actions from UML Activity Diagrams as discussed in [Van den Bergh06, Nóbrega et al.05]. While this is basically possible, au- thors agree that using standard Activity Diagrams would lead to a limited usability for the modeler and adaptations are desired.

In particular for transformations into other models or code, it is often necessary to specialize the semantics of UML even if the notation remains unchanged. For example, defining that in a State Chart each state represents a Presentation Unit is an extension of the the semantics of UML states. Thus, UML usually has to be extended anyway. Existing UML extensions for user interface modeling

mainly use the stereotype mechanism (see section 3.4.3). Examples are theWisdomapproach [Nunes

and Falcão e Cunha00, Nunes01] or UMLi [da Silva and Paton00, da Silva and Paton03] which support the basic user interface models like in figure 4.1. TheContext-sensitive User Interface Profile(CUP, [Van den Bergh and Coninx05, Van den Bergh and Coninx06, Van den Bergh06] supports a similar approach like Dynamo-Aid (section 4.1.2). Besides, a few other approaches aim for a integration of the task concept with more general Software Engineering concepts: For example, [Sinnig et al.07] defines a common semantic domain for task models and Use Cases or [Bourguin et al.07] describes a component-based approach where each component represents a (generic) user task.

As the area of model-driven engineering is relatively young, currently only a few user interface modeling approaches comply to its concepts and upcoming standards. Basically, many user interface modeling approaches constitute themselves as “model-based” (instead of “model-driven”) but this is often not intended as a statement about the degree of automation. UsiXML provides explicit meta- models and supports transformations and adheres to many MDE concepts [Vanderdonckt05]. Some of the latest approaches explicitly adhere to MDE concepts and tools: [Botterweck06] addresses the de- velopment of user interfaces for multiple target devices. [Sottet et al.07b, Coutaz et al.07] focuses on development and runtime adaptation of user interfaces for ambient spaces. Both approaches provide EMF-compliant metamodels and ATL transformations between them.

Automation and Usability

An important general challenge lies in the degree of automation and, related with that, the usability of resulting user interfaces. Applying the idea of model-driven development, more concrete models

would be automatically derived from abstract models by transformations and modified and completed by the developer. On the other hand, automation can easily lead to user interfaces whose provided de- gree of usability is not sufficient. An example for intensive automation is JANUS [Balzert95, Balzert et al.96] which is still available as a commercial tool [Otr]. It generates the user interfaces directly from the domain model. Although it provides various possibilities for the user to tune the transforma- tion, the resulting user interfaces tend to reflect the application model instead of the user’s conceptual model. Such user interfaces are useful to provide user access e.g. on database values but are often not sufficient to support a less experienced user through his/her tasks. Thus, such highly automated de- velopment approaches are usually considered as adequate only for very specific application domains [Puerta and Eisenstein99]. [Arens and Hovy95] is another example addressing in particular multi- media: It proposes an intelligent system (calledCicero) which aims to automatically select a media representation for a given piece of information and specified user.

The opposite alternative is to specify all models up to the final implementation manually – maybe even in parallel and by different persons – and finally to specify manually the relationships between them required to complete the overall specification – e.g. between task model or dialog model and interaction objects. In the literature the problem how to establish the relationship between the different

models is referred to as Mapping Problem [Puerta and Eisenstein99] which is discussed in several

contributions [Limbourg et al.00, Clerckx et al.04, Montero et al.05]. As pointed out by [Szekely96], any approach should give the possibility for manual post-editing to provide the interface designer the final control about the results and not to hinder him/her to revise the final results.

While manual specification of models and mappings aims to ensure usability by leaving the re- sponsibility to the human developer, it remains still desirable to increase productivity by a possibly high amount of automation. One of the most important arguments for user interface modeling men- tioned above – the possibility to generate user interfaces for different devices which might even be unknown at design time – would become quite weak if no (semi-)automatic transformation from platform-independent user interface models to platform-specific user interfaces exist. Moreover, even a non-automated but systematic approach should include as much knowledge as possible about how to systematically achieve appropriate usability. Thus, it is useful to formalize knowledge about usability, or at least make it explicit, as much as possible.

A common definition from the ISO standard onErgonomics of Human System Interaction[ISO98]

defines usability as:

The extent to which a product can be used by specified users to achieve specified goals with effectiveness, efficiency and satisfaction in a specified context of use.

From the viewpoint of Software Engineering usability is usually considered as one of the non- functional requirements. While some approaches for formalizing and modeling non-functional re- quirements already exist [Zschaler07], it currently seems not possible to adopt them for usability as there currently is not even a concept how usability could be measured at all [Seffah and Metzker04].

The HCI domain has provided several collections of usability guidelines and patterns. Guide- lines are generic rules to be obeyed when designing a user interface. Some guidelines are often very

concrete, as found in guidelines for operation systems like theApple Human Interface Guidelines

[App08] or theGNOME Human Interface Guidelines[GNO04] for GNOME desktops. They spec-

ify for instance the look of widget components and distances between them on the screen. Such guidelines can often be integrated into code generators easily so that the code generator helps to obey them. Other guidelines are very generic and qualitative rules like the design rules in [Shneiderman and Plaisant04, Nielsen93, Preece et al.94, Constantine and Lockwood99], for instance the rule that a user interface should be consistent. Some formal rules can be indirectly derived from them, e.g. by

generating the same kind of widgets for similar user tasks. Model driven development can be valuable for realizing such rules as it allows to implement, manage, and maintain them by explicit declarative transformation rules, as sketched in first proposals by [Sottet et al.06, Zhao and Zou07].

However, the problem remains that usability guidelines are often contradictory, e.g. using the same kind of widgets for similar tasks can conflict with the rule that the user interface should prevent errors, for instance by using widgets which allows only valid inputs. A possible solution can be to treat this as an optimization problem with a cost function which is user specific and adapts according to the user’s usage of the generated user interfaces like in SUPPLE [Gajos and Weld04].

Another promising solution is to build on existing established manually created building blocks, i.e. user interface patterns. Examples for existing user interface pattern collections are [Tidwell05, van Welie, Duyne et al.02]. An approach for integrating patterns into user interface generation is pre- sented in [Radeke and Forbrig07, Radeke et al.06]. They provide theUser Interface Pattern Extensi- ble Markup Language(UsiPXML) to describe patterns and their implementations in machine-readable form. UsiPXML describes the patterns in terms of model fragments based on an adapted version of UsiXML. The authors propose a general framework how to integrate patterns into model-based user interface development and apply it as example to their development approach presented in [Wolff et al.05].

The model driven solution from Sottet et.al. aims to integrate such mechanisms. They propose a mix of automated, semi-automated and manually performed transformations. The approach aims to enable flexible integration of any usability framework into the transformation. The transformations are treated as models and, thus, usability guidelines can be managed and maintained in terms of models as well. In particular, a transformation can be associated with properties representing one or more usability rules (see [Sottet et al.07a]).

As follow up step on that base, it seems desirable to create customized user interfaces for the user interface designer which allow to manage the transformations – including guidelines and patterns – as proposed e.g. by [Sottet et al.06]. This idea was already supported to some extent by earlier tools like Mobi-D [Puerta and Eisenstein99]. Moreover, the end-user might also need a “Meta-UI” which allows to control and customize the user interface adaptations at runtime in ambient spaces as claimed by [Coutaz06].

Initiatives

In general, modeling is a highly active research area in Software Engineering (see section 3.4). Hence the interchange between user interface modeling area and Software Engineering area is important. User interface modeling can profit from the evolving concepts, tools, and standards from the MDE community. In turn, results from HCI are important for Software Engineering as the usability of ap- plications is a key factor for its success. In addition, user interface modeling can be an important application area for applying and evaluating the theory of modeling as due to the large experience existing in this field. An increasing number of efforts investigates into this directions, e.g. confer- ences and workshops like the HCSE conference mentioned above or HCI-SE and books like [Seffah et al.05]. Another initiative is the workshop onModel Driven Development of Advanced User Inter- faces(MDDAUI) co-organized by the author of this thesis and so far held three times on the MODELS conference (one of the main conferences on MDE) in 2005 [Pleuß et al.05b, Pleuß et al.05a], 2006 [Pleuß et al.06b, Pleuß et al.06a], and 2007 [Pleuß et al.07c, Pleuß et al.07a]

ER OMT UML OOHDM RMM WebML HDM W2000 WSDM HDM-Lite UWE OO-H WAE WAE2 Data-oriented methods Hypertext-oriented methods Object-oriented methods Software-oriented methods 4th generation 3rd generation 2nd generation 1st generation Underlying modeling language

Figure 4.8: Web Engineering approaches according to [Schwinger and Koch03]