The next generation of networked mechatronic systems will be characterized by complex coordination and structural adaptation at run-time. Crucial safety properties have to be guaranteed for all potential structural configurations. Testing cannot provide safety guarantees, while current model checking and theorem proving techniques do not scale for such systems. We present a verification technique for arbitrarily large multi-agent systems from the mechatronic domain, featuring complex coordination and structural adaptation. We overcome the limitations of existing techniques by exploiting the local character of structural safety properties. The system state is modeled as a graph, system transitions are modeled as rule applications in a graph transformation system, and safety properties of the system are encoded as inductive invariants (permitting the verification of infinite state systems). We developed a symbolic verification procedure that allows us to perform the computation on an efficient BDD-based graph manipulation engine, and we report performance results for several examples.

The development of dependable software systems is a costly undertaking. Fault tolerance techniques as well as self-repair capabilities usually result in additional system complexity which can even spoil the intended improvement with respect to dependability. We therefore present a pattern-based approach for the design of service-based systems which enables self-managing capabilities by reusing proven fault tolerance techniques in form of Fault Tolerance Patterns. The pattern specification consists of a service-based architectural design and deployment restrictions in form of UML deployment diagrams for the different architectural services. The architectural design is reused when designing the system architecture. The deployment restrictions are employed to determine valid deployment scenarios for an application. During run-time the same restrictions are at first used to automatically map additional services on suitable nodes. If node crashes are detected, we secondly employ the restrictions to guide the self-repair of the system in such a way that only suitable repair decisions are made.

Abstract. The general trend towards complex technical systems with embedded software results in an increasing demand for dependable high quality software. The UML as an advanced object-oriented technology provides in principle the essential concepts which are required to handle the increasing complexity of these safety-critical software systems. However, the current and forthcoming UML versions do not directly apply to the outlined problem. Available hazard analysis techniques on the other hand do not provide the required degree of integration with software design notations. To narrow the gap between safety-critical system development and UML techniques, the presented approach supports the compositional hazard analysis of UML models described by restricted component and deployment diagrams. The approach permits to systematically identify which hazards and failures are most serious, which components or set of components require a more detailed safety analysis, and which restrictions to the failure propagation are assumed in the UML design.

Web services, service-oriented, and service-discovery architectures help developers solve complex business cases, reduce costs, risks, and time-to-market. The task of developers is challenged by the difficulty of guaranteeing interoperability with target web services, since the lack of information about the interaction protocol of dynamically discovered web services may lead to unexpected runtime failures. This paper proposes an approach to design self-adaptive serviceoriented architectures. The approach enables clients to automatically adapt their behavior to alternative web services that provide compatible functionality through different interaction protocols. It uses an infrastructure that traces the successful interactions of the web services, automatically synthesize models that approximate the interaction protocols, and steer client-side adaptations at runtime.

No abstract