Frank Alexander Kraemer

Tool support for the rapid composition, analysis and implementation of reactive services

We present the integrated set of tools Arctis for the rapid development of reactive services. In our method, services are composed of collaborative building blocks that encapsulate behavioral patterns expressed as UML 2.0 collaborations and activities. Due to our underlying semantics in temporal logic, building blocks as well as their compositions can be transformed into formulas and model checked incrementally in order to guarantee that important system properties are kept. The process of model checking is fully automated. Error traces are presented to the users as easily understandable animations, so that no expertise in temporal logic is needed. In addition, the results of model checking are analyzed, so that in some cases automated diagnoses and fixes can be provided as well. The formal semantics also enables the correct, automatic synthesis of the activities to state machines which form the input of our code generators. Thus, the collaborative models can be fully automatically transformed into executable Java code. We present the development of a mobile treasure hunt system to exemplify the method and the tools.

Service Specification by Composition of Collaborations--An Example

We outline a specification style for reactive services that focuses on UML 2.0 collaborations and activities as reusable specification building blocks, In contrast to traditional component-based approaches, a collaboration directly describes the interactions between the components as well as the internal behavior necessary for a component to take part in it. To compose services from such reusable collaborations, we use events identified as input and output pins on the activities that are connected together. While our approach is formally settled in temporal logic, in this paper we focus on an example specification from the viewpoint of a service engineer

ALIGNING UML 2.0 STATE MACHINES AND TEMPORAL LOGIC FOR THE EFFICIENT EXECUTION OF SERVICES

In our service engineering approach, services are specified by UML 2.0 collaborations and activities, focusing on the interactions between cooperating entities To execute services, however, we need precise behavioral descriptions of physical system components modeling how a component contributes to a service For these descriptions we use the concept of state machines which form a suitable input for our existing code generators that produce efficiently executable programs From the engineering viewpoint, the gap between the collaborations and the components will be covered by UML model transformations To ensure the correctness of these transformations, we use the compositional Temporal Logic of Actions (cTLA) which enables us to reason about service specifications and their refinement formally In this paper, we focus on the execution of services By outlining an UML profile, we describe which form the descriptions of the components should have to be efficiently executable To guarantee the correctness of the design process, we further introduce the cTLA specification style cTLA/e which is behaviorally equivalent with the UML 2.0 state machines used as code generator input In this way, we bridge the gap between UML for modeling and design, cTLA specifications used for reasoning, and the efficient execution of services, so that we can prove important properties formally.

Automated Encapsulation of UML Activities for Incremental Development and Verification

With their revision in the UML 2.x standard, activities have been extended with streaming parameters. This facilitates a reuse-oriented specification style, in which dedicated functions can be contributed by self-contained activities as building blocks: Using streaming parameters, activities can be composed together in a quite powerful manner, since streaming parameters may also pass information while activities are executing. However, to compose them correctly, we must know in which sequence an activity may emit or accept these streaming parameters. Therefore, we propose special UML state machines that specify the externally visible behavior of activities. Further, we develop an algorithm to construct these state machines automatically for an activity based on model checking. Using these behavioral contracts, activities can then be composed without looking at their internal details. Moreover, the contracts can be used during system verification to reduce the complexity of the analysis.

Reactive semantics for distributed UML activities

We define a reactive semantics for a subset of UML activities that is suitable as precise design language for reactive software systems. These semantics identify run-to-completion steps for execution on the level of UML activities as so-called activity steps. We show that activities adhering to these semantics and a set of rules lead to event-driven and bounded specifications that can be implemented automatically by model transformations and executed efficiently using runtime support systems.

Using UML 2.0 collaborations for compositional service specification

Collaborations and collaboration uses are features new to UML 2.0. They possess many properties that support rapid and compositional service engineering. The notion of collaboration corresponds well with the notion of a service, and it seems promising to use them for service specification. We present an approach where collaborations are used to specify services, and show how collaborations enable high level feature composition by means of collaboration uses. We also show how service goals can be combined with behavior descriptions of collaborations to form what we call semantic interfaces. Semantic interfaces can be used to ensure compatibility when binding roles to classes and when composing systems from components. Various ways to compose collaboration behaviors are outlined and illustrated with telephony services.

Transforming Collaborative Service Specifications into Efficiently Executable State Machines

We describe an algorithm to transform UML 2.0 activities into state machines. The implementation of this algorithm is an integral part of our tool-supported engineering approach for the design of interactive services, in which we compose services from reusable building blocks. In contrast to traditional approaches, these building blocks are not only components, but also collaborations involving several participants. For the description of their behavior, we use UML 2.0 activities, which are convenient for composition. To generate code running on existing service execution platforms, however, we need a behavioral description for each individual component, for which we use a special form of UML 2.0 state machines. The algorithm presented here transforms the activities directly into state machines, so that the step from collaborative service specifications to efficiently executable code is completely automated. Each activity partition is transformed into a separate state machine that communicates with other state machines by means of signals, so that the system can easily be distributed. The algorithm creates a state machine by reachability analysis on the states modeled by a single activity partition. It is implemented in Java and works directly on an Eclipse UML2 repository.

Engineering android applications based on UML activities

With the evolving capabilities of devices, mobile applications are emerging towards complex reactive systems. To handle this complexity and shorten development time by increased reuse, we propose an engineering approach based on UML activities, which are used like building blocks to construct applications. Libraries of such building blocks make Android-specific features available. Tool support provides automatic formal analysis for soundness and automatic implementation. Furthermore, the approach is easily extensible, since new features can be provided by new building blocks, without changing the tools or notation. We demonstrate the method by a voice messaging application.

Synthesizing components with sessions from collaboration-oriented service specifications

A fundamental problem in the area of service engineering is the so-called cross-cutting nature of services, i.e., that service behavior results from a collaboration of partial component behaviors. We present an approach for model-based service engineering, in which system component models are derived automatically from collaboration models. These are specifications of sub-services incorporating both the local behavior of the components and the necessary inter-component communication. The collaborations are expressed in a compact and self-contained way by UML collaborations and activities. The UML activities can express service compositions precisely, so that components may be derived automatically by means of a model transformation. In this paper, we focus on the important issue of how to coordinate and compose collaborations that are executed with several sessions at the same time. We introduce an extension to activities for session selection. Moreover, we explain how this composition is mapped onto the components and how it can be translated into executable code.

Design of Trusted Systems with Reusable Collaboration Models

We describe the application of our collaboration-oriented software engineering approach to the design of trust-aware systems. In this model-based technique, a specification does not describe a physical system component but the collaboration between various components which achieve system functions by cooperation. A system model is composed from these collaboration specifications. By a set of transformations, executable code can be automatically generated. As a modeling language, we use UML 2.0 collaborations and activities, for which we defined a semantics based on temporal logic. Thus, formal refinement and property proofs can be provided by applying model checkers as well. We consider our approach to be well-suited for the development of trust-based systems since the trust relations between different parties can be nicely modeled by the collaborations. This ability facilitates also a tight cooperation between trust management and software engineering experts which are both needed to create scalable trust-aware applications. The engineering approach is introduced by means of an electronic auction system executing different policies which are guided by the mutual trust of its principals. While the approach can be used for various trust models, we apply Josang’s Subjective Logic in the example.