Usually, Web-based graphical user interfaces (GUIs) are not specifically tailored for different devices with touch-screens, such as smartphones and tablet PCs, where interaction is affected mainly by screen size. There is little scientific evidence on the conditions under which additional taps for navigation are better than scrolling or vice versa. Therefore, we conducted a user study in which we experimentally evaluated GUIs tailored for a smartphone and a tablet PC, respectively. Each participant performed the same task with two different layouts of the same GUI, either on a given smartphone or tablet PC. We collected quantitative data through measuring task completion time and error rates, as well as qualitative data through subjective questionnaires. The main result is that tailoring a GUI specifically for a smartphone or tablet PC, respectively, is important, since screen size matters. Users performed significantly better when they could use the tailored version on the given device. This preference was also reflected in their subjective opinions.

Automated generation of Window / Icon / Menu / Pointing Device User Interfaces (WIMP UIs) has some potential, but there are still many unresolved issues involved, that lead, e.g., to usability problems. In particular, there are several problems concerning the derivation of behavior models of such user interfaces from a high-level interaction model. These problems are related to parallelism and granularity of communication units. In this paper, we present a new process for the automated derivation of a WIMP-UI behavior model from a given high-level Discourse Model. Our new process can handle parallelism in these models and supports different granularities of communication units. This solves certain problems of WIMP-UI generation related to behavior models.

Fission of several output modalities poses hard problems, and (semi-)automatically configuring it is even more difficult. However, it is important to address the latter in order to broaden the scope of providing user interfaces semi-automatically. Our approach starts from a high-level discourse model created by a human interaction designer. It is modality-independent,so a modality-annotated discourse model is semi-automatically generated. Based on it, our fission is semiautomatically configured. It currently supports output modalities graphical user interface, (canned) speech output, and a new modality that we call movement as communication. The latter involves movements of a semi-autonomous robot in 2D-space for reinforcing the communication of the other modalities.

When using a software development method without tool support, developers are often asking how to do what the method instructs them to do. When using a CASE tool without a method, developers are often asking what to do with the tool. Therefore, we propose an approach to method-tool coupling that helps developers following the instructions of a given method by using the supporting tool in the right way. According to this approach, we show how to couple a given method with a supporting tool. We present a prototypical implementation that links a Web-based method representation with so-called cheat sheets, from where tool functionality can be directly invoked. The method represented in the Web pages prescribes the primary tasks to do, while the instructions for the secondary tasks are available in the cheat sheets embedded in the tool.

Automatic generation of user interfaces (UIs) has made some progress, but it still faces many challenges, especially when starting from high-level models. We developed an approach and a supporting tool for modeling discourses, from which the tool can generate WIMP (window, icon, menu, pointer) UIs automatically. This involves several complex steps, most of which we have been able to implement using model-driven transformations. When given specific target platform specifications, UIs for a variety of devices such as PCs, mobile phones and PDAs can be generated automatically.

Programming graphical user interfaces is hard and expensive, while automatic generation is still quite challenging. One of the issues involved in automatic generation is the presentation of content from the domain of discourse according to its purpose in the current context of the human-machine dialogue. For example, it makes a difference whether the same piece of information is to be presented in the context of asking a user something, or simply for the purpose of informing. We address this issue through generating content presentation specifically according to the type of communicative act, that indicates the purpose. In the course of transforming a high-level discourse model to a structural user interface model, we apply specific model-transformation rules to content types, depending on the type of communicative act they are referred from. This results in automatically generated user interfaces with content presentations according to purpose.

Development of GUIs (graphical user interfaces) for multiple devices is still a time-consuming and error-prone task. Each class of physical devices - and in addition each application-tailored set of physical devices - has different properties and thus needs a specifically tailored GUI. Current model-driven GUI generation approaches take only few properties into account, like screen resolution. Additional device properties, especially pointing granularity, allow generating GUIs suited for certain classes of devices like touch screens. This paper is based on a model-driven UI development approach for multiple devices based on a discourse model that provides an interaction design. Our approach generates UIs using an extended device specification and applying model transformation rules taking them into account. In particular, we show how to semi-automatically generate finger-based touch screen UIs and compare them with usual UIs for use with a mouse that have also been generated semi-automatically.

Model-driven transformations allow the generation of lower-level models and code from higher-level models of a software design, where all these artifacts are in the solution space. The situation is inherently different, however, for transformations from problem space to solution space. The architectural design cannot be fully transformed from requirements in general, since this would imply that the transformation would involve a "magic" problem solver. We investigate and discuss this issue to figure out what can be mapped or transformed for a given set of requirements. While an architectural style or pattern can be selected according to given (non-functional) requirements, this does not mean that the architecture is transformed from requirements. Still, it is possible to transform select parts of a software architecture representation tentatively from certain requirements representations. However, adaptations of the rules or of the generated result will usually be needed.

End users of software typically have to let someone else develop it and its user interface, or to learn to design and to program it themselves. Especially user interfaces developed by someone else may not fit well the given task. Designing and programming is hard and takes a lot of effort in general, and even more so for people not especially trained or experienced.

Instead of developing user interfaces (UIs) directly, we argue for specifying an interaction design from which UIs can be automatically synthesized. We present an approach to using communicative acts in high-level specification of interaction design, which is implemented and allows automated synthesis of interfaces for multiple devices. Communicative acts derive from speech act theory and carry desired intentions in interactions. Models of communicative acts, UI domain objects and interaction sequences comprise interaction design specifications in our approach and are based on a metamodel that we have defined. As a result, the usability of a synthesized user interface of a real-world application turned out to be good

User interfaces are very important for the success of many computer-based applications these days. However, their development takes time, requires experts for user-interface design as well as experienced programmers and is very expensive. This problem becomes even more severe through the ubiquitous use of a variety of devices such as PCs, mobile phones, PDAs etc., since each of these devices has its own specifics that require a special user interface.Therefore, we developed a tool-supported approach to automatically synthesize multi-device user interfaces from high-level specifications in the form of models. In contrast to previous approaches focusing on abstracting the user interface per se, we make use of communicative acts derived from speech act theory for the specification of desired user intentions in interactions. In this way, we approach a solution to the given problem, since user interfaces can be efficiently provided without experience in implementing them.

We use HTML and Java to enable relational databases for the World Wide Web and provide a comparison between both techniques based on practical experiences. We introduce a novel design and implementation technique for database backed Web applications based on a state machine model. The key idea is to create a design language to describe the user interface layout, the functionality and the database transactions in a homogenous way. The implementation of such a system is then composed from several parts with potentially different techniques, for example either a pure HTML interface with all its functionality at the server side or a Java applet with more functionality at the client side. The goal is to generate the different implementations automatically from the design language. With this development framework the design and implementation of various database backed Web applications will be easier, faster and less error prone.