A software product line is a set of products that share a set of software features and assets, which satisfy the specific needs of one or more target markets. One common artefact of software product line engineering is a feature model, usually represented as a directed acyclic graph, which shows the product line as a set of structural feature relationships. We argue that there are benefits to considering a feature model as a directed graph and an undirected graph, respectively. One element of managing the impact of a change to these models, as they increase in complexity, is to evaluate the relative importance of the features. This paper explores the application of centrality metrics from social network analysis for the identification of the relative importance of features in feature models. The metrics considered are degree centrality, closeness centrality, eccentricity centrality, eigenvector centrality and between-ness centrality. To illustrate, a product feature model is constructed from a real-world GSMA AI-mobile phone product line requirements specification.

As a software product line evolves a significant management challenge is comparing existing products to each other or planned products. The approach to product comparison will vary according to its purposes. One solution includes the representation of a configured product as a weighted binary string where 1 represents a feature’s presence, 0 represents its absence, and the weight represents the different levels of relative importance to the product that a feature is perceived to have. Relative importance values influence similarity matching so that the features considered important are the ones that primarily influence what is judged to be similar. A binary string similarity metric supports product comparison (a product similarity metric). For a product line that contains thousands of features the allocation of relative importance values is only practical when done automatically. This paper proposes a novel algorithm for automatically determining the relative importance of each feature. A feature tree can represent a product line in which a feature is a node in the tree and a relationship between features is an edge. A feature’s relative importance is calculated as a function of local and global tree structural measures. The local measures are the number of input and output nodes to which a feature is connected and the variability property of each of these nodes. The global measure is the distance of the feature from the root node. A mobile phone worked example illustrates the feasibility of the algorithm.

The volume, variety and velocity of products in software-intensive systems product lines is increasing. One challenge is to understand the range of similarity between products. Reasons for product comparison include (i) to decide whether to build a new product or not (ii) to evaluate how products of the same type differ for strategic positioning or branding reasons (iii) to gauge if a product line needs to be reorganized (iv) to assess if a product falls within the national legislative and regulatory boundaries. We will discuss two different approaches to address this challenge. One is grounded in feature modelling, the other in case-based reasoning. We will also describe a specific product comparison process in which a product configured from a product line feature model is represented as a weighted binary string, the overall similarity between products is compared using a binary string metric, and the significance of individual feature combinations for product similarity can be explored by modifying the weights. We will illustrate our ideas with a mobile phone example, and discuss some of the benefits and limitations of this approach.

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.

This tutorial presents and compares two different approaches to requirements reuse. The first approach deals with requirements reuse and reusability using feature modelling. The second approach deals with requirements reuse and reusability in the context of case-based reasoning. Both approaches have different key properties and trade-offs between the costs of making software artefacts reusable and the benefits of reusing them. To aid large-scale development, we have proposed a Feature-Similarity Model, which draws on both approaches to facilitate discovering requirements relationships using similarity metrics. A FeatureSimilarity Model also helps with exploring stakeholder needs, since new requirements can be introduced first into a case base and then gradually included into a product line representation.

Formal design verification receives increased importance since the complexity of safety-critical technical applications steadily increases. In this paper, we describe an approach for symbolic model checking of collaborative robotic systems against safety properties. In particular, the methodology presented enables verification even under system modifications and adaptive behavior generally represented as variability. Architectural, behavioral and environmental models are correspondingly abstracted to reach a balance of generality and verifiability with reasonable effort. To demonstrate the proposed method, we use the model of a collaborative assembly use case and formally verify the existence of mechanical clamping hazards between the robot’s moving end effector and static environment objects.

We observe ever increasing variability of hardware/software interfaces (HSIs), e.g., in automotive systems. Hence, there is a need for the reuse of already existing HSIs. In this regard, an important question is whether automated adaptation of an already existing HSI to one that fulfills the requirements on a new HSI is feasible in industrial practice. Ideally, the number of adaptation steps should be minimal, so that new hardware production can be avoided. In this paper, we address the problem of finding such an optimal solution for a given specific HSI and a set of formally specified requirements on a new HSI. We propose using design space exploration employing (heuristic) search with optimality guarantees. Hence, a meta-model of such HSIs has been created together with transformation rules. Based on all that, an experimental evaluation of this approach shows its feasibility for realistic HSIs.

When the requirements and the interaction design of a system are separated, they will most likely not fit together, and the resulting system will be less than optimal. Even if all the real needs are covered in the requirements and also implemented, errors may be induced by human-computer interaction through a bad interaction design and its resulting user interface. Such a system may even not be used at all. Alternatively, a great user interface of a system with features that are not required will not be very useful as well. This tutorial explains joint modeling of (communicative) interaction design and requirements, through discourse models and ontologies. Our discourse models are derived from results of human communication theories, cognitive science and sociology (even without employing speech or natural language). While these models were originally devised for capturing interaction design, it turned out that they can be also viewed as specifying classes of scenarios, i.e., use cases. In this sense, they can also be utilized for specifying requirements. Ontologies are used to define domain models and the domains of discourse for the interactions with software systems. User interfaces for these software systems can be generated semi-automatically from our discourse models, domain-of-discourse models and specifications of the requirements. This is especially useful when user interfaces for different devices are needed. Specific usability requirements can be dealt with in our approach through advanced customization approaches. Hence, inter-action design facilitates requirements engineering to make applications both more useful and usable.

Software reuse and reusability range from operational, ad-hoc and short-term to strategic, planned and long-term. Often the focus of attention is just on code or low-level design. This tutorial presents and compares two different requirements-led approaches. The first approach deals with requirements reuse and reusability using feature modelling. The second approach deals with requirements reuse and reusability in the context of case-based reasoning. Both approaches have different key properties and trade-offs between the costs of making software artefacts reusable and the benefits of reusing them. To aid large-scale development, we have proposed a Feature-Similarity Model, which draws on both approaches to facilitate discovering requirements relationships using similarity metrics. A Feature-Similarity Model also helps with the evolution of a product line, since new requirements can be introduced first into a case base and then gradually included into a product line representation.

Several socioeconomic trends are increasing personalised customer demands. Suppliers are responding with mass customisation but the management of large-scale cost-effective software reuse remains a difficult challenge. Software reuse and reusability range from operational, ad-hoc and short-term to strategic, planned and long-term. Often the focus of attention is just on code or low-level design. This tutorial presents and compares two different requirements-led approaches. The first approach deals with requirements reuse and reusability in the context of product line engineering. The second approach deals with requirements reuse and reusability in the context of case-based reasoning. Both approaches have different key properties and trade-offs between the costs of making software artefacts reusable and the benefits of reusing them. To aid large-scale development we have proposed a Feature-Similarity Model, which draws on both approaches to facilitate discovering requirements relationships using similarity metrics. A Feature-Similarity Model also helps with the evolution of a product line, since new requirements can be introduced first into a case base and then gradually included into a product line representation.

For explicit representation of commonality and variability of a product line, a feature model is mostly used. An open question is how a feature model can be inductively learned in an automated way from a limited number of given product specifications in terms of features.

Several socio-economic trends are driving customer demands towards individualisation. Many suppliers are responding by offering supplier-led software product design customization choices ("mass customization"). Some are also offering customer-led software product design choices ("mass personalization"). This tutorial introduces these concepts and explores the implications for software product line development. One particular technical challenge is being able to respond to and manage at scale the increasing variety of common, supplier-led and customer-led features. We discuss two different approaches to address this challenge. One is grounded in feature modelling; the other in case-based reasoning. Both approaches aim to support the identification and selection of similar products. However they each place different emphases on these activities, use different product descriptions, and deploy different product derivation methods. Accordingly, each approach has different key properties, benefits and limitations.

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.

There is a gap between theory and practice regarding the assessment of minimaxing versus product propagation. The use of minimaxing in real programs for certain two-player games like chess is more or less ubiquitous, due to the substantial search space reductions enabled by several pruning algorithms. In stark contrast, some theoretical work supported the view that product propagation could be a viable alternative, or even superior on theoretical grounds. In fact, these rules have different conceptual problems. While minimaxing treats heuristic values as true values, product propagation interprets them as independent probabilities. So, which is the better rule for backing up heuristic values in game trees, and under which circumstances? We present a systematic analysis and results of simulation studies that compare these backup rules in synthetic trees with properties found in certain real game trees, for a variety of situations with characteristic properties. Our results show yet unobserved complementary strengths in their respective capabilities, depending on the size of node score changes (“quiet” versus “nonquiet” positions), and on the degree of advantage of any player over the opponent. In particular, exhaustive analyses for shallow depths show that product propagation can indeed be better than minimaxing when both approaches search to the same depth, especially for making decisions from a huge amount of alternatives, where deep searches are still prohibitive. However, our results also provide some justification for the more or less ubiquitous use of minimaxing in chess programs, where deep searches prevail and the pruning algorithms available for minimaxing make the difference.

Feature-based systems may have interacting features, where undesired feature interaction(s) may even lead to safety-critical behavior in cyber-physical systems. Automotive systems are such systems, where more and more features are currently being integrated, which have to be coordinated. Automated and formal verification of the resulting behavior against safetyrelevant properties is important, and it should not be restricted to the cyber-part (inside the software implementing the features.)In order to address this problem, we investigate coordination of physical feature interactions in this context using model checking. In particular, we created and used a qualitative model for formal verification against a property in time logic. This model is intended to be minimalist, in particular the logical model based on a physical model (including speed and distance). This logical model defines the essence of operations in the dedicated environment. As a result, we formally verified the high-level logic of a composite feature to be used in automotive systems against a formalized accident property. In summary, we employ minimalist qualitative models for model checking (safety-critical) cyberphysical feature coordination. Such a verified qualitative model may provide a reference model for both quantitative models and real software implementations.

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.

How can the application domain and the requirements be better understood using object-oriented (OO) modeling? How do scenarios / use cases fit together with functional requirements? How can a domain model be used for a model-based transition to a design model? This tutorial addresses these questions in the following manner. It shows how each requirement given in natural language can be viewed itself as an object and modeled as such. This approach facilitates both a hierarchical organization (by grouping requirements instances into classes and subclasses) and explicit association (by relating requirements through OO associations). While scenarios / use cases can somehow illustrate the overall functionality, additionally functional requirements for the system to be built should be formulated and related to them appropriately. All kinds of requirements make statements about the application domain, which should be first represented in a domain model of conceptual classes, in order to make the requirements better understandable. This tutorial explains a seamless transition to a high-level design model, where design classes are abstractions of implementation classes. This transition from requirements to software design is also investigated in model-driven terms, whether it is a transformation or just a mapping. In addition, the influence of non-functional requirements for selecting an architecture is explained.

Software reuse is often just addressed at the level of code or low-level design. In contrast, this tutorial explains software reuse based on business processes and requirements. It presents and compares three approaches co-developed by the presenter over more than a decade. The first of these approaches deals with requirements reuse in the context of product lines. It makes the relations among product line requirements explicit, so that single system requirements in this product line can be derived consistently. A key issue is commonality and variability across different products. This tutorial shows how requirements for a product line can be modeled, selected and reused to engineer the requirements for innovative new products. The second approach for software reuse involves case-based reasoning. Instead of explicit relations between requirements (or other artifacts), similarity metrics are employed for finding the most similar software case in a repository to a given set of requirements. This even works when a single envisioned usage scenario is specified yet, and it allows reusing also requirements from retrieved cases. The major point, however, is to facilitate reusing software design (including architecture) and code from similar software cases. The third approach (still under development) strives for (partly) automating software development for certain business applications through reusing business knowledge and software, where both are tightly connected. It involves automated reuse of business processes, and software executing them, based on ontological knowledge. A key point is closing the representational gap between procedurally represented business processes and declaratively represented concepts and their relations, taxonomies, partonomies, etc. So, this is an ontology-based approach for (partly) automated software development guided by business models.

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.

In state-of-the-art automotive systems, many automated driving features such as adaptive cruise control are usually integrated in various combinations. These combinations may lead to undesired feature interaction, where one such feature creates conditions that interfere with the proper execution of one or more of the other features. In such a situation, the usability of the vehicle or even the safety of humans may become compromised. We propose to improve Systems Engineering for coordinating feature implementations to avoid undesired feature interaction. In particular, we reuse knowledge on addressing a certain recurring problem with a proven (generalized) solution in the form of a so-called Pattern that has been devised in the field of object-oriented Software Engineering. The so-called Mediator Pattern organizes the work of software parts that otherwise would have many interfaces among each other, leading to high coupling. We devise such a Mediator at design-time, so that at runtime known undesired feature interactions can be avoided by the resulting system. A prototypical implementation in a real automotive system and its test demonstrate the feasibility of this approach in the sense, that known feature interactions can be avoided in a systematic way.

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.

Automation systems become more and more complex, and their traditional hierarchical and centralized control may not be able to deal with this ever-increasing complexity satisfactorily. Decentralized approaches are considered promising, but they are not yet sufficiently understood for widespread industrial application. In particular, agent-based control has not yet achieved its potential, so that more research is still required. Our approach is based on the concept of an automation agent composed of a hardware (HW) component and a software (SW) component, where the HW component can be viewed as an embodiment of this SW component. These agents represent the parts of a flexible automation system. In particular, we propose that each such agent has an explicit symbolic representation of itself and of its relations to its environment. More precisely, this new agent architecture contains a reflective world model that includes a representation of this same agent and of its relations to its environment. In addition, the world model contains representations of situations and activities. We show that and how such a self-representation can be used for self-configuration, as well as monitoring, including failure detection in automation systems. The agent performs this self-configuration without any human intervention and just based on a brief specification of the HW configuration. The monitoring is based on automatically raised expectations for the system's behavior and allows failure detection without any specific failure detection code.

Automation in the course of user-interface (UI) development has the potential to save resources and time. For graphical user interfaces, quite some research has been performed on their automated generation. While the results are still not in wide-spread use, at least the problems are well understood meanwhile. In contrast, automated generation of multimodal UIs is still in its infancy. We address this problem by proposing a tool-supported process for generating multimodal UIs for dialogue-based interactive systems. For its concrete enactment, we provide tool support for generating a runtime configuration and glue code, respectively. In a nutshell, our approach generates multimodal dialogue-based UIs semi-automatically.

A well-known problem in requirements engineering is the communication between stakeholders with different background. This communication problem is mostly attributed to the different “languages” spoken by these stakeholders based on their different background and domain knowledge. We experienced a related problem involved with transferring and sharing such knowledge, when stakeholders are reluctant to do this. So, we take a knowledge management perspective of requirements engineering and carry over ideas for the sharing of knowledge about requirements and the domain. We cast requirements engineering as a knowledge management process and adopt the concept of the spiral of knowledge involving transformations from tacit to explicit knowledge, and vice versa. In the context of a real-world problem, we found the concept of “knowledge holders” and their relations to categories of requirements and domain knowledge both useful and important. This project was close to become a failure until knowledge transfer has been intensified. The knowledge management perspective provided insights for explaining improved knowledge exchange.

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.

A case-based approach allows reuse without the usual and significant effort for making software explicitly reusable. We even support such reuse for only partially developed requirements, since it allows reuse already without the need to develop a “complete” specification first. The solution information (models and code) of (one of) the most similar problems can then be taken for reuse and adapted to the newly specified requirements. And even the specification of these new requirements can be facilitated, since the retrieved software case contains related requirements, which may be reused as well.

Goal-oriented requirements engineering has been extensively studied and it certainly has a lot of appeal and potential. However, it is not (yet) in wide-spread industrial use. We conjecture as a major reason that the existing approaches are somewhat isolated and generally too complex. The latter reason makes them difficult to apply in real-world projects. Therefore, we distill the essence of goal-oriented requirements engineering and unify it in a simple and comprehensive approach. We also connect it with more common approaches like scenario based requirements engineering (including use cases). As another step towards better applicability, we define a metamodel for a modeling language that allows representing all kinds of goals and their relationships in UML style.

Even if we have recognized many short-term benefits of agile methods, we still know very little about their long-term effects. In this panel, we discuss the long-term perspective of the agile methods. The panelists are either industrial or academic representatives. They will discuss problems and benefits related to the long-term lifecycle system management in agile projects. Ideally, the panel's outcome will provide ideas for future research.

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.

The minimaxing approach to backing-up heuristic values has been very successful, e.g., in computer chess for making move decisions on the world-champion level, by employing very deep searches and effective pruning algorithms. From a theoretical point of view, however, it is not yet clear whether minimaxing or product propagation is better in terms of decision quality without deep searches. We present a systematic analysis of game trees with depth 2, where a single application of the competing back-up rules each (in a given branch from the root of the search tree) reveals their pure decision quality. Interestingly, product propagation tends to make better decisions per se more frequently, under realistic assumptions modeled after real game-playing programs. So, its decision quality may still make it a viable alternative for game trees where only shallow searches are affordable.

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.

Manufacturing systems have become very complex, and the traditional hierarchical and centralized approaches are not adequate any more. Decentralized approaches are considered promising, but they are not yet sufficiently understood for widespread industrial application. In particular, agent-based control has not yet achieved its potential, so that more research is still required. Therefore, we propose a new architecture of automation agents. Such an agent is composed of a hardware component and a software component, where the hardware component can be viewed as an embodiment of this software component in its manufacturing environment. An important part of the software component is a world model repository of the automation agent. As a special innovation, the world model is reflective in the sense, that it contains a symbolic representation of the automation agent and of its relations to its environment as well. The world model repository is made up of representations of situations and activities. In summary, we propose an automation agent architecture with a reflective world model for use in manufacturing systems.

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.

In this panel, we propose to figure out how requirements engineering and interaction design can be usefully combined. In particular, some people argue that scenarios/ use cases should be concrete, as in story-telling. Others argue for use of "essential" use cases as a methodological approach to interaction and user-interface design. Somewhat in the middle, it is argued that use cases should help acquiring the requirements in the first place. What should the practitioner believe and, in particular, do, in order to develop useful and usable software and systems? Software development and interaction design require different skills and different methods and are typically done by different people. Still, scenario-based design is proposed for several activities relevant for both tasks, such as requirements elicitation, software design, and interaction design. Symbolic modeling in this spirit is actually common to various fields. However, scenario-based approaches vary, especially with regard to their use, e.g., employing abstract use cases or integrating scenarios with functions and goals in a systematic design process. So, the key issue to be raised at the panel is how to combine different approaches, e.g., in scenario-based development, so that the interaction design as well as the development of the user interface and of the software internally result in an overall useful and useable system.

Requirements and user interface specifications are often separated from each other and do not fit together. We integrate them in a newly defined requirements specification language (RSL). In particular, RSL allows explicit linking of requirements artefacts with elements of the user interface specification. Some of these elements are modality independent,while others can be viewed as a prototype of the ldquolookrdquo of the user interface. This integration along the representation dimension is supposed to facilitate combined work on requirements and user interfaces along the process dimension as well.

In order to make requirements comprehensible to humans and as unambiguous as possible, a glossary and/or domain model is needed for defining the terminology used. Unless these are available from related projects, however,they are hard to create. Therefore, we propose to reuse terminology and its definition for requirements specifications from the semantic lexicon WordNet. For making this useful, however, we had to deal with the issue of disambiguation of the general terminology there for a given domain of a requirements specification.

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.

Software systems and in particular also knowledge-based systems (KBS) become increasingly large and complex. In response to this challenge, software engineering has a long tradition of advocating modularity. This has also heavily influenced object-oriented development. For measuring certain important aspects of modularity, coupling and cohesion metrics have been developed. Metrics have also attracted considerable attention for object-oriented development. For KBS development, however, no such metrics are available yet. This article presents the core of the first metrics suite for KBS development, its coupling and cohesion metrics. These metrics measure modularity in terms of the relations induced between slots of frames through their common references in rules. We show the soundness of these metrics according to theory and report on their usefulness in practice. As a consequence, we propose using our metrics in order to improve KBS development, and developing other important metrics and assessing their theoretical soundness along these lines.

Reuse and requirements are very important for efficient and successful systems development. This tutorial presents the experiences of requirements reuse using a Method for Requirements Authoring and Management (MRAM). MRAM is a method for establishing and selecting from product line requirements. A product line is a group of products within the same market segment e.g. mobile phones. TRAM (Tool for Requirements Authoring and Management) is a software tool to support MRAM that utilises current proven office technology (MS-Word, MS-Access). The tutorial presents the results of MRAM/TRAM as it has been applied to product line engineering of a real-world application.

Most of the work on search in artificial intelligence (AI) deals with one search direction only-mostly forward search-although it is known that a structural asymmetry of the search graph causes differences in the efficiency of searching in the forward or the backward direction, respectively. In the case of symmetrical graph structure, however, current theory would not predict such differences in efficiency. In several classes of job sequencing problems, we observed a phenomenon of asymmetry in search that relates to the distribution of the are costs in the search graph. This phenomenon can be utilized for improving the search efficiency by a new algorithm that automatically selects the search direction. We demonstrate fur a class of job sequencing problems that, through the utilization of this phenomenon, much more difficult problems can be solved-according to our best knowledge-than by the best published approach, and on the same problems, the running time is much reduced. As a consequence, we propose to check given problems for asymmetrical distribution of are costs that may cause asymmetry in search.

While promising approaches to early system design using scenarios have been proposed, no design process is available that guides scenario-based design. We present a model that combines scenarios both with functions and goals. Functions are required to make the desired behavior of some scenario happen in order to achieve one or more goals. Using this model, we propose a systematic and concrete design process that is both model-driven and data-driven. Our design process supports the transition from the current to a new system and guides the design of a new system. In addition, this process makes it possible to detect a certain kind of redundancy and to improve both completeness and understandability of the resulting design. We have applied our approach in real-world projects, and our experience suggests the utility of this approach.

Reuse and requirements engineering are very important for efficient and successful systems development. However there are many open issues for performing them well in practice, especially raise of requirements. We present a new approach to reusing requirements based on application families i.e. several systems in a given problem domain. In contrast to precious approaches, an application family model in our approach consists of a pool of requirements (linked in a lattice structure), a domain model and a set of discriminants (a special kind of requirement that differentiate one system from another). We focus on how to make an efficient and clean selection of the requirements for a new system from an application family model. We have developed a method for solving this problem and a prototypical tool for supporting it. The method and the prototype were successfully developed under a study contract for ESA (European Space Agency). We present a case study, where we generated commanding requirements for an individual mission from an application family model of commanding requirements for spacecraft control operating systems. As a consequence, we propose this approach for reusing requirements based an application families.

The assessment of bidirectional heuristic search has been incorrect since it was first published more than a quarter of a century ago. For quite a long time, this search strategy did not achieve the expected results, and there was a major misunderstanding about the reasons behind it. Although there is still wide-spread belief that bidirectional heuristic search is afflicted by the problem of search frontiers passing each other, we demonstrate that this conjecture is wrong. Based on this finding, we present both a new generic approach to bidirectional heuristic search and a new approach to dynamically improving heuristic values that is feasible in bidirectional search only. These approaches are put into perspective with both the traditional and more recently proposed approaches in order to facilitate a better overall understanding. Empirical results of experiments with our new approaches show that bidirectional heuristic search can be performed very efficiently and also with limited memory. These results suggest that bidirectional heuristic search appears to be better for solving certain difficult problems than corresponding unidirectional search. This provides some evidence for the usefulness of a search strategy that was long neglected. In summary, we show that bidirectional heuristic search is viable and consequently propose that it be reconsidered.

This article investigates the notion of reasoning types and tries to contribute to its clarification, placing special emphasis on relationships to AI programming paradigms. There are probably several different dimensions of reasoning. Here we identify two dimensions, one of which orders reasoning types along the scale "inductive/deductive", whereas the other is closely related to programming paradigms. We would argue for the combination of reasoning types along both these dimensions. In fact, we have integrated heuristic and causal reasoning with various AI programming paradigms and traditional procedure-oriented programming in a kind of hybrid programming, using each method where we decided it fit "best". Since we concentrate in this article on software engineering aspects of building knowledge-based systems, we focus on issues related to the second dimension. In particular, the control knowledge can be represented by a stylized combination of rules and conventional procedures. We postulate that there is a whole spectrum between these extreme paradigms, and that an appropriate balance in the combination of rule-based and procedure-oriented programming can fit the given degree of ordering. Object-oriented programming and frame-based representation serve as a useful means for integrating multiple programming paradigms. Finally, we describe the duality of abstract data types and access-oriented programming, utilizing this view for some suggestions for their respective use.

Some light is shed on the issue of why bounded look-ahead search can be beneficial. While this question has received some attention in the context of two-player perfect-information games, the authors also consider it for single-agent problem solving. Primarily, they focus on what makes minimaxing this useful in game-playing practice (especially in computer chess). They investigate a class of models based on domain-independent definitions of quiescence, observing more and more realistic behavior with more and more realistic definitions. As a global result, these models show beneficial behavior based on the specific properties of the tree and especially without the need for improvements of the evaluation function toward the end of the game or even error-free evaluations. In contrast, the model investigated for single-agent problem solving needs improved accuracy of the static values with increasing depth to make look-ahead beneficial.>

Investigation of several algorithms for computing exact minimax values of game trees (utilizing backward pruning) are discussed. The focus is on trees with an ordering similar to that actually found in game playing practice. The authors compare the algorithms using two different distributions of the static values, the uniform distribution and a distribution estimated from practical data. A systematic comparison of using aspiration windows for all of the usual minimax algorithms is presented. The effects of aspiration windows of varying size and position are analyzed. Increasing the ordering of moves to near the optimum results in unexpectedly high savings. Algorithms with linear space complexity benefit most. Although the ordering of the first move is of predominant importance, that of the remainder has only second-order effects. The use of an aspiration window not only makes alpha-beta search competitive, but there also exist dependencies of its effects on certain properties of the trees.>