this article we show the power of this approach. On the one hand, UWE prescribes how to build navigation and presentation models for Web applications defining therefore special UML stereotyped modeling elements and tagged values. On the other hand, we show how these Web specific navigation and presentation models can be supplemented by other views using the variety of UML diagram types and UML modeling elements. Our current research activities focus on the dynamic aspects of the design of Web applications, such as task modeling and modeling of Web scenarios, graphical representation of the distribution of Web components and semi-automatic generation of Web applications based on design models

In this paper we present a method for the semiautomatic transition from the design models of a Web application to a running implementation. The design phase consists of constructing a set of UML models such as the conceptual model, the navigation model and the presentation model. We use the UML extension mechanisms, i.e. stereotypes, tagged values and OCL constraints, thereby defining a UML Profile for the Web application domain. We show how these design models can automatically be mapped to XML documents with a structure conforming to their respective XML Schema definitions. Further on we demonstrate techniques how XML documents for the conceptual model are automatically mapped to conceptual DOM objects (Document Object Model). DOM objects corresponding to interactional objects are automatically derived from conceptual DOM objects and/or other interactional DOM objects. The XSLT mechanism serves to transform the logical presentation objects representing the user interface to physical presentation objects, e.g. HTML or WAP pages. Finally we present a production system architecture for Web applications using the XML publishing framework Cocoon which provides a very flexible way to generate documents comprising XSLT and XSP (eXtensible server pages) processors.

This work is about supporting user interface design by means of explicit design representations, in particular models.

this paper a metamodel (i.e. abstract syntax) for the UWE methodology, which could then be joined with metamodels that are/will be defined for other methods. It is defined as a conservative extension of the UML metamodel (UML, 2001). This metamodel provides a precise description of the concepts used to model Web applications and their semantics. Our methodology UWE is based on this metamodel including tool support for the design and for the semi-automatic generation of Web applications. We further define a mapping from the metamodel to the notation (i.e. concrete syntax) used in UWE

The construction of software systems is becoming increasingly complex because of the changing environments the software is supposed to function in. Taking into account the context of use, how the system reacts and anticipates changes in its working environment, is important for a wide range of applications, such as mobile services for example. Model-driven design is already widely accepted as a software engineering methodology to cope with these new type of requirements. This approach is known both in software engineering (e.g. model-driven architecture) as in the design of user interfaces (model-based user interface development), but although they target the same deficiencies from traditional approaches, there is still a gap between both. New modeling elements are necessary that allow the designer to make both context of use and user interactions explicit in the design phase and to create context-sensitive software that will be more robust and usable. We extend the UML 2.0 notation to address the aforementioned issues and present extensions to support the modeling of context-sensitive interactive applications. These extensions are defined in a new UML profile that can easily be used in existing modeling environments.

The development of multimedia applications is a branch of software development of increasing importance. Many advanced user interfaces integrate multimedia elements, and critical multimedia systems are emerging, e.g. in training and simulation areas. Multimedia user interfaces pose a number of new challenges to the software development process and technologies. Unfortunately, software engineering principles are mostly ignored in current practice of multimedia application development. This paper suggests a way of how the gap between multimedia applications and software engineering can be made smaller. A modeling language is presented which is based on UML 2.0, but is tailored for effective, platform-independent abstractions from concrete multimedia technologies. Using such a modeling language, we show it is possible to apply the paradigm of Model-Driven Development to multimedia applications, leading to better structured and more maintainable applications, and a much higher degree of independence from multimedia platform technologies. The language is described using a medium-sized case study, and concepts for prototypical tools supporting model-driven development of multimedia applications are outlined.

Abstract. This paper presents an approach to diminish the effort required in GUI modelling and test coverage analysis within a model-based GUI testing process. A familiar visual notation – a subset of UML with minor extensions – is used to model the structure, behaviour and usage of GUIs at a high level of abstraction and to describe test adequacy criteria. The GUI visual model is translated automatically to a model-based formal specification language (e.g., Spec#), hiding formal details from the testers. Then, additional behaviour may be added to the formal model to be used as a test oracle. The adequacy of the test cases generated automatically from the formal model is accessed based on the structural coverage of the UML behavioural diagrams. Keywords: GUI modelling, GUI testing, model-based testing, UML, Spec#. 1

Automatic generation of user-interfaces is a key-technology enabling designers to cope with the increasing diversity of computing devices that are becoming ubiquitous and reaching a growing number of users. Although model based generation of UIs failed to reach commercial adoption, the technology is widespread today on the Web through device independent rendering of markup. This paper presents a new approach to this problem that provides automatic generation of multiple user interfaces from UML-based high-level specifications. From a minimal set of UML extensions that promote high-level modeling of UI specifics, we demonstrate how we can automatically generate intent-based UI descriptions capable of being rendered in multiple devices. Moreover, our approach takes advantage of the XMI tools interchange format, thus promoting tool independence and taking advantage of XML technologies, like XSL transformation. We also envision how this approach could be transposed into the forthcoming W3C XForms standard, thus enabling a more ambitious approach for flexible automatic generation of UIs.

{ link | kopp | abeck} @ cm-tm.uka.de Human interaction like entering some data, making decisions etc. has to be dealt with as an integral part of today’s business processes and the supporting IT likewise. Hence, human interaction leads to an increased complexity in software development and software systems. Current business- and model-driven development approaches provide promising means to deal with this complexity. Diverse aspects of the business process and the supporting software system are captured in models and automatically transformed to the source code of a desired platform. In the context of human interaction however, there remains a lack of precise models for specifying human interaction aspects. Thus, an extensive manual development and configuration effort is necessary leading to expensive software, badly configured interfaces and frustrated users. In this article, we therefore demonstrate a model-driven development approach focusing on human interaction as an integral part of business processes and software systems likewise. A case study fortifies the applicability of our approach. 1.

The first version of the XIS profile addressed the development of interactive systems by defining models oriented only towards how the system should perform tasks. However, issues such as user-interface layouts, or the capture of interaction patterns, were not addressed by the profile, but only by the source-code generation process. This originated systems that, although functional, were considered by end-users as “difficult to use”. In this paper we present the second version of the XIS UML profile, which is now a crucial component of the ProjectIT research project. This profile follows the “separation of concerns” principle by proposing an integrated set of views that address the various issues detected with the previous version of XIS. In addition, this profile also promotes the usage of extreme modeling, by relying on the extensive use of model-to-model transformation templates that are defined to accelerate the model development tasks. 1