Process models in general, and those specifying process-oriented software in particular, should be formally verified. While activity-oriented process models have been verified against object life cycles, formally specified semantic specifications of actions were not involved. Hence, previous approaches for the verification of process models did not make use ofdeclarativelyrepresented knowledge of actions. This paper presents a new approach for verification of consistency between process models, object life cycles, and context-dependent semantic action specifications. This approach involves declarative specifications of all the actions of a process, which also depend on the context of use of the actions. These context-dependent specifications define the ‘logic’ of the process flow, which is grounded in (extended) object life cycles. Since asubtypingrelation is enforced, reuse is facilitated through substitutability. Our extension of object life cycles makes them applicable to processes including non-monotonicity, and even to model communication based on physical interaction in cyber-physical systems. As a consequence, this formal consistency verification ensures that all the involved specifications ‘fit together’, both procedurally and logically.

Much like semantic service specification, semantic specification of tasks in business processes is needed, e.g., for their formal verification. In addition to the specification of the pure effects of some procedural code, however, business context plays a major role for semantic task specification. Open questions are how to include the business context of a task in its semantic specification, and what the semantic specification of a task composition is. This paper clarifies the relation of service composition with corresponding task composition in different business context using semantic specification. It shows that a specific semantic service task specification may become a supertype of the corresponding semantic service specification. Hence, it provides a theoretical basis for the reusability of (Web) services in different business contexts. This paper also presents a systematic derivation of the semantic specification of sequential task composition. Based on all that, it shows recursive application for higher-level business processes.

Business processes are changing over time, e.g., due to new or changed legal regulations. Complex processes are susceptible to change, since they capture much detail and/or deal with variability according to context. Manual adaptation of process models according to such changes takes time and is error-prone. In order to address these issues, primarily complexity, we propose to model high-level reference processes with less detail than the fully-fledged processes. The missing details are captured in additional business rules that operationalize how an organization performs miscellaneous tasks. Their application to a high-level reference process leads to its refinement. Technically, we propose explicit separation of process models (represented in BPMN) and specifications of business rules (represented as model-transformation rules based on the BPMN 2.0 metamodel). Applying such rules as model transformations to process models (at design-time) leads to models of either refined or adjusted models of business processes. In this way, even without any extension of the BPMN 2.0 standard, these model adaptations can handle the required changes of business processes.

Risk analysis and requirements engineering for safety-critical systems are expensive and challenging, especially for the very high reliability required, e.g., in the automotive and railway industries. Currently, risk analysis is performed by safety engineers with little or no explicit reuse. Of course, these engineers build on their previous experience in this course, but explicit reuse of related artefacts, e.g., from a dedicated repository is not available according to our best knowledge.

Interaction design is supposed to investigate alternatives, but these alternative designs should not have to be reinvented from scratch. This entails the need for reusability of interaction design knowledge, especially of different (parts of) solutions for similar problems. In particular, the definition of specific interaction design models is a prerequisite for automated generation of graphical user interfaces (GUIs). A useful approach to capture knowledge about (generalized) solutions for common problems in a given context are patterns. So, we propose here interaction design patterns. More precisely, this paper presents alternative interaction design patterns for automated GUI generation with Discourse-based Communication Models. The solutions specified in these patterns are dialogue fragments often occurring in Discourse Models. Our approach allows the interaction designer to investigate alternatives in the design space without having to reinvent them.

In general, Interaction Design is considered important for achieving usable user interfaces, but in terms of specification languages for this purpose, there is not much agreement. In contrast, for more specific Interaction Design in the context of automated (G)UI generation, Task Models are the most widely used approach. The more recent Discourse-based approach in this context is much less widely understood. It focuses on the specification of (classes of) dialogues in contrast to tasks for modeling activities that can be performed by the user or the application (system). We identified a duality of Interaction Design according to these approaches to high-level modeling for GUI generation, which we explain and elaborate in this paper. In this course, we contrast the different models, which specify largely corresponding abstractions of Interaction Design, but from different views and with a different design philosophy. As a consequence, mutual understanding of these different modeling approaches should be improved. Based on this duality, suggestions for mutual improvements can be made, so that the tool-box of interaction designers wishing to have GUIs generated automatically from their models should become more general and flexible.

In the research on automated (design-time) generation of graphical user interfaces (GUIs), the focus is on how such a generation works and on the resulting GUI's appearance. However, the integration of the software part implementing the resulting GUI with an application logic does not appear to be in a well-defined software architecture. We propose an integration in the well-known Model-View-Controller (MVC) architecture, with its decoupling of different concerns and the resulting software properties. We show that most of its components can be automatically generated from Discourse-based Communication Models. We also show how these models connect to an application logic. In this way, we present an implemented and tested approach to connecting a high-level interaction model and the Web-based GUI software generated from it with an application logic and its implementation in the context of model-driven GUI generation.

Creating and optimizing content- and dialogue-based recommendation processes and their GUIs (graphical user interfaces) manually is expensive and slow. Changes in the environment may also be found too late or even be overlooked by humans. We show how to generate such processes and their GUIs semi-automatically by using knowledge derived from unstructured data such as customer feedback on products on the Web. Our approach covers the whole lifecycle from knowledge discovery through text mining techniques to the use of this knowledge for semi-automatic generation of recommendation processes and their user interfaces as well as their comparison in real-world use within the e-commerce domain through A/B-variant tests. These tests indicate that our approach can lead to better results as well as less manual effort.

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.

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.

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.

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.