Today, software components are provided by global markets in the form of services. In order to optimally satisfy service requesters and service providers, adequate techniques for automatic service matching are needed. However, a requester's requirements may be vague and the information available about a provided service may be incomplete. As a consequence, fuzziness is induced into the matching procedure. The contribution of this paper is the development of a systematic matching procedure that leverages concepts and techniques from fuzzy logic and possibility theory based on our formal distinction between different sources and types of fuzziness in the context of service matching. In contrast to existing methods, our approach is able to deal with imprecision and incompleteness in service specifications and to inform users about the extent of induced fuzziness in order to improve the user's decision-making. We demonstrate our approach on the example of specifications for service reputation based on ratings given by previous users. Our evaluation based on real service ratings shows the utility and applicability of our approach.

The automated planning in Cyber-Physical Production Systems (CPPS) reduces the need for the human-error-prone repetitive planning task. Modeling CPPS and the required products for planning purposes can be done with domain-independent planning languages, like Planning Domain Definition Language or Prolog. However, such domain-independent languages do not satisfy all requirements in CPPS, like concurrency and/or time. Moreover, production engineers should deal with the planning models of their systems and, therefore, such models must be usable (understandable) for these users. Unfortunately, these requirements are missing in the available domain-independent planning languages. To overcome the previous problems, we develop an object-oriented planning language specific for the domain of CPPS. To evaluate the CPPS requirements' satisfaction, we use the language to represent the planning problem of two simulated robotic arms cooperating on an assembly task.

The Collaborative Research Centre "On-The-Fly Computing" works on foundations and principles for the vision of the Future Internet. It proposes the paradigm of On-The-Fly Computing, which tackles emerging worldwide service markets. In these markets, service providers trade software, platform, and infrastructure as a service. Service requesters state requirements on services. To satisfy these requirements, the new role of brokers, who are (human) actors building service compositions on the fly, is introduced. Brokers have to specify service compositions formally and comprehensively using a domain-specific language (DSL), and to use service matching for the discovery of the constituent services available in the market. The broker's choice of the DSL and matching approaches influences her success of building compositions as distinctive properties of different service markets play a significant role. In this paper, we propose a new approach of engineering a situation-specific DSL by customizing a comprehensive, modular DSL and its matching for given service market properties. This enables the broker to create market-specific composition specifications and to perform market-specific service matching. As a result, the broker builds service compositions satisfying the requester's requirements more accurately. We evaluated the presented concepts using case studies in service markets for tourism and university management.

The problems of planning production processes in Cyber Physical Production Systems (CPPS) require information about e.g., machines, products, and time. These information can be modeled with languages which have different characteristics. Production engineers must select a language carefully when modeling their problems. Otherwise, they have to put an extra effort (e.g., to work around temporal constraints) later when selecting an unsuitable language. A suitable selection can be achieved by a comparison that provides engineers with decision support. In related work, comparisons among such languages exist. However, these comparisons are not tight to the context of CPPS. To provide a decision support, we suggest criteria to compare among languages when used for planning in CPPS. We apply these criteria on the languages: Prolog, Timed Automata, and PDDL. Other languages will be considered in our future work.

One of the main ideas of Service-Oriented Computing (SOC) is the delivery of flexibly composable services provided on world-wide markets. For a successful service discovery, service requests have to be matched with the available service offers. However, in a situation in which no service that completely matches the request can be discovered, the customer may tolerate slight discrepancies between request and offer. Some existing fuzzy matching approaches are able to detect such service variants, but they do not allow to explicitly specify which parts of a request are not mandatory. In this paper, we improve an existing service matching approach based on Visual Contracts leveraging our preliminary work of design pattern detection. Thereby, we support explicit specifications of service variants and realize gradual matching results that can be ranked in order to discover the service offer that matches a customer's request best.

Embedded real-time systems are increasingly applied in safety-critical environments like cars or aircrafts. Even though the system design might be free from flaws, hazardous situations may still be caused at run-time by random faults due to the wear of physical components. Hazard analysis is based on fault trees or failure propagation models. These models are created at least partly manually. They are usually independent from the software models which are used for checking safety and liveness properties to avoid systematic faults. This is particularly bad in cases, where the software model contains manually specified operations to deal with random faults which have been identified by hazard analysis. These operations include replacing the faulty components by reconfiguration. We propose to generate a failure propagation model automatically from the software model to check whether the results of hazard analysis have been properly accounted in the specification of reconfiguration operations. In contrast to other approaches, our approach considers the real-time properties of the system and adds explicit failure propagation times based on using timed automata for model specification.

Technical systems contain mechanical, electrical, and software parts. Consequently, they are developed by engineers of the respective disciplines. However, current industrial practice as well as existing development processes do not account for the required tight integration between the engineers of the different disciplines. Processes become even more complex, when self-adaptive systems are built. In this paper, we present a development process for self-adaptive mechatronic systems which particularly addresses the integration between the disciplines concerned with the development of software, namely control and software engineering. We illustrate the process by presenting examples from the development of autonomous railway vehicles which build convoys to improve energy efficiency.

Modern technical systems are increasingly built to exhibit self-x properties as, e.g., self-healing or self-optimization. For this, they require adaptation at runtime. This is even true for embedded or mechatronic systems which often operate in safety-critical environments. There, the effects of the adaptation with respect to safety must be analyzed carefully. However, not all parameters needed for safety analyses, e.g., the concrete system architecture, are known at design time. Consequently, safety analyses need to be executed during runtime. Current approaches of runtime safety analysis typically react to anomalies that already occurred in the system. Thus, unsafe system states cannot be excluded completely. We present a runtime safety analysis that prevents system states with an unacceptable risk that have not yet occurred. For this, we generate the reachable component structures at runtime and analyze them with respect to risk. The system is modified such that component structures with an unacceptable risk are not reachable any more and are thus prevented.

No abstract available.

We present a Tool Suite which supports the (re-)construction of a behavioral model of a legacy component based on a learning approach by exploiting knowledge of known models of the existing component environment. This in turn enables to check whether the legacy component can be integrated correctly into its environment.

The role of an existing systems architecture (SA) in requirements engineering (RE) is recognised as important, but under-researched. A recent exploratory study of ours investigated this issue in a laboratory setting involving student participants. While the initial findings are promising, much work still remains to solidify the results. Therefore, we conducted a replication of the study, and its significant extension, on a large-scale prototypical rail project. Specifically, we identify (i) the effects of SA on RE decisions, (ii) the characteristics of the RE decisions and (iii), the impact of such decisions on development activities and the rail system. The findings of this study have implications on tighter RE-SA integration across subsystems, impact analysis of requirements on SA, and planning and risk management. We also propose three emergent hypotheses from this case study as a driver for future empirical work in RE. This case study involved examining the 10-year history of requirements and architecting decisions in several major components of the rail project. The data collected was from numerous project documents and extensive interviews with the developers and planners.

The four papers in this special section are extended versions of selected papers from the 16th ACM International Symposium on the Foundations of Software Engineering, held in Atlanta, Georgia, 11-13 November 2008.

Based on a well-defined component architecture the tool supports the synthesis of so-called real-time statecharts from timed sequence diagrams. The two step synthesis process addresses the existing scalability problems by a proper decomposition and allows the user to define particular restrictions on the resulting statecharts.

We address these challenges by the model-driven mechatronic UML development approach which combines domain specific modeling and refinement techniques with verification based on compositional model checking. The approach suggests modeling the software by using a refined UML 2.0 component model including the detailed definition of ports, connectors, and patterns. We further refine the component model to define a proper integration between discrete and continuous control such that the reconfiguration of hierarchical component systems can be described in a modular way. Compositional model checking is based on a domain specific decomposition of the system specification into individually checkable components based on a common pre-defined architectural model. As a basis for formal verification, a formal semantic definition of the concepts taken from UML 2.0 is given. For the scope of this presentation, this is particularly done for our notion of so-called real-time statecharts. Besides supporting compositional verification, the approach supports checking consistency between different parts of a systems specification by a syntax check. This check is based on giving a formal definition of consistency.

The development of complex mechatronic systems requires a careful and ideally verifiable design. In addition, engineers from different disciplines, namely mechanical, electrical and software engineering, have to cooperate. The current technology is to use block diagrams including discrete blocks with statecharts for the design and verification of such systems. This does not adequately support the verification of large systems which improve the system behavior at run-time by means of online reconfiguration of its controllers because the system as whole has to be verified. It also does not support cooperative interdisciplinary work because a white-box view on all blocks involved in the online reconfiguration is required. This paper proposes a rigorous component concept based on the notion of UML component diagrams which enables modular composition and decomposition of complex systems with online reconfiguration given by hierarchical hybrid component specifications. The approach enables compatibility checks between components that are often independently developed (across the different disciplines) and supports compositional model checking based on a rigorously defined semantics.

A method and a corresponding tool is described which assist design recovery and program understanding by recognising instances of design patterns semi-automatically. The approach taken is specifically designed to overcome the existing scalability problems caused by many design and implementation variants of design pattern instances. Our approach is based on a new recognition algorithm which works incrementally rather than trying to analyse a possibly large software system in one pass without any human intervention. The new algorithm exploits domain and context knowledge given by a reverse engineer and by a special underlying data structure, namely a special form of an annotated abstract syntax graph. A comparative and quantitative evaluation of applying the approach to the Java AWT and JGL libraries is also given.

Interest in the use of processes to provide assistance in software development activities remains at a high level. But the focus of attention has shifted in recent years. Early work emphasizing the study of languages for defining processes was rapidly eclipsed by process evaluation and improvement work, most notably the Capability Maturity Model (CMM). As process improvement has matured as a strategy and philosophy it has also given rise to a strong reaction to the perception that it is unduly ponderous and constraining. Movements such as Extreme Programming (XP) have cast themselves as lightweight alternatives, emphasizing the primacy of freedom and flexibility. Both philosophies and communities continue to grow in size, development, and depth of understanding.The goal of this panel will be to explore the differences between these major approaches to the use of process in software development by bringing together leading articulate exponents of the approaches. Each panelist will be charged with presenting a very concise characterization of the approach being represented. But the focus of the panel will be on understanding the nature of the differences in approach, and the reasons for these differences. Similarities will be sought as well.An underlying hypothesis of the panel is that the differences in approach arise in large measure from differences in objective and differences in assumptions about the software development context. Thus, for example, one approach may be intended to support very long range organizational objectives, while the other may be more tactically oriented. One approach may assume that evolvability is an overriding objective, while another may be more focused on speed to market. One may make stronger assumptions about the skills and training of project personnel. The panel will attempt to delve into these issues to see if it may be possible to suggest criteria for suggesting which approach (and possible adaptation) should be selected for a given development situation.In a larger sense, the goal of this panel is to suggest the possibility of a discipline of software process engineering. Insofar as the panel is able to suggest that development situations can be used to guide the selection of process approaches to the provision of assistance, might this then be an indication that process formalisms could play a role in subsequent specification of detailed processes, and evaluation of their effectiveness?The panel will react to this and related questions. While lively interchanges among the panelists will be stimulated and expected, similar interchanges with the audience will also be cultivated.

No abstract available.

No abstract available.

Object-oriented technology has become mature enough to satisfy many new requirements coming from areas like computer-aided design (CAD), computer-integrated manufacturing (CIM) or software engineering (SE). However, a competitive information management infrastructure often demands the merging of data from CAD, CIM or SE systems with business data stored in a relational system. In addition, complex dependencies between those data stored in the different systems might exist and should be maintained. One approach for seamless integration of object-oriented and relational systems is to migrate the data (and the corresponding schema) from a relational to an object-oriented system. In this paper, we describe an integrated design environment that supports the migration process and overcomes the major drawbacks of comparable approaches.

The key topic is the way how the Merlin process-centered environment provides execution of rule-based persistent software processes.Any software process in Merlin is described by rules which are executed either in a forward chaining or backward chaining mode and which are made persistent by storing them in an object-oriented data base.After a brief introduction to the general Merlin concepts the paper focuses on the representation of rtdes in the underlying data base and their correspcmding flexible and efficient execution.

The subject of this paper is the description of a process-centered software development environment called MERLIN which monitors and guides teams of software developers and managers in producing software objects. Software objects (or objects for short) include all sorts of documents like requirements analysis, design, code, user manuals, contracts etc. For each user, MERLIN automatically displays a specific working context which contains information like objects, their relations, their current development state, and corresponding tools. This information is filtered according to the (access) rights and duties a particular user has in a particular project, i.e. the working context depends on the user's role (e.g. programmer, designer, manager). Internally, the computation of the information to be contained in a working context, is based on a rulelike definition of a software process and a flexible interpretation mechanism to enact such a process definition. The main feature of the interpreter is an alternating use of backward and forward chaining for the interpretation of rules. In addition, our implementation enables a persistent storage and incremental update during runtime of all process information expressed in facts within the MERLIN knowledge base.

The conceptual modeling approach of the IPSEN (Integrated Project Support Environment) project for building highly integrated environments is based on using attributed graphs to model and implement arbitrary object structures, in particular all kinds of software documents and their relationships. A language based on graph grammars, called PROGRESS (PROgrammed Graph REwriting SyStems), and a suitable method for the application of this language, called graph grammar engineering, have been developed over the last ten years. This language and method are being extensively used for specifying the complex graph structures of internal document representations as well as for specifying the functionality of all tools (editors, browsers, analyzers, debuggers) working on these internal rpresentations. This paper explains the language and the method for applying the language based on a pragmatic nontrivial example of a software production process and its corresponding documents. In particular, it is shown why and how a graph grammar-based strongly typed language is perfectly suitable to formally specify highly integrated software tools. In addition, it is shown that the implementation of these tools (i.e., an environment composed of these tools) is systematically being derived from the formal specifications.

The Prism model of engineering processes and an architecture which captures this model in its various components are described. The architecture has been designed to hold a product software process description the life-cycle of which is supported by an explicit representation of a higher-level (or meta) process description. The central part of this paper describes the nine-step Prism methodology for building and tailoring process models and gives several scenarios to support this description. In Prism, process models are built using a hybrid process modeling language that is based on a high-level Petri net formalism and rules. An important observation is that this environment should be seen as an infrastructure for carrying out the more difficult task of creating sound process models.>