Alexander Knapp

Model Checking UML State Machines and Collaborations

Abstract The Unified Modeling Language provides two complementary notations, state machines and collaborations, for the specification of dynamic system behavior. We describe a prototype tool, HUGO , that is designed to automatically verify whether the interactions expressed by a collaboration can indeed be realized by a set of state machines. We compile state machines into a PROMELA model and collaborations into sets of Buchi automata (“never claims”). The model checker SPIN is called upon to verify the model against the automata.

Semantic-Based development of service-oriented systems

Service-oriented computing is an emerging paradigm where services are understood as autonomous, platform-independent computational entities that can be described, published, categorised, discovered, and dynamically assembled for developing massively distributed, interoperable, evolvable systems and applications. The IST-FET Integrated Project Sensoria aims at developing a novel comprehensive approach to the engineering of service-oriented software systems where foundational theories, techniques and methods are fully integrated in a pragmatic software engineering approach. In this paper we present first ideas for the Sensoria semantic-based development of service-oriented systems. This includes service-oriented extensions to the UML, a mathematical basis formed by a family of process calculi, a language for expressing context-dependent soft constraints and preferences, qualitative and quantitative analysis methods, and model transformations from UML to process calculi. The results are illustrated by a case study in the area of automotive systems.

Model Checking - Timed UML State Machines and Collaborations

We describe a prototype tool, HUGO/RT, that is designed to automatically verify whether the timed state machines in a UML model interact according to scenarios specified by time-annotated UML collaborations. Timed state machines are compiled into timed automata that exchange signals and operations via a network automaton. A collaboration with time constraints is translated into an observer timed automaton. The model checker UPPAAL is called upon to verify the timed automata representing the model against the observer timed automaton.

Model checking of UML 2.0 interactions

The UML 2.0 integrates a dialect of High-Level Message Sequence Charts (HMSCs) for interaction modelling. We describe a translation of UML 2.0 interactions into automata for model checking whether an interaction can be satisfied by a given set of message exchanging UML state machines. The translation supports basic interactions, state invariants, strict and weak sequencing, alternatives, ignores, and loops as well as forbidden interaction fragments. The translation is integrated into the UML model checking tool HUGO/RT.

Modelling adaptivity with aspects

Modelling adaptive Web applications is a difficult and complex task. Usually, the development of general system functionality and context adaptation is intertwined. However, adaptivity is a cross-cutting concern of an adaptive Web application, and thus is naturally viewed as an aspect. Using aspect-oriented modelling techniques from the very beginning in the design of adaptive Web applications we achieve a systematic separation of general system functionality and context adaptation. We show the benefits of this approach by making navigation adaptive.

Interactive Verification of UML State Machines

We propose a new technique for interactive formal verification of temporal properties of UML state machines. We introduce a formal, operational semantics of UML state machines and give an overview of the proof method which is based on symbolic execution with induction. Usefulness of the approach is demonstrated by example of an automatic teller machine. The approach is implemented in the KIV system.

UWE4JSF: A Model-Driven Generation Approach for Web Applications

Model-driven engineering is a promising approach, but there are still many hurdles to overcome. The tool UWE4JSF solves the hurdles for the model-driven development of web applications designed with UWE. It builds upon a set of models and domain specific annotations --- in particular an abstract and a concrete presentation model. It is completely integrated in Eclipse, implemented as a set of plugins supporting model transformations and fully automatic code generation.

A Component Model for Architectural Programming

Abstract Software architectures and modular composition help in constructing large-scale software systems. Current programming languages provide only insufficient support for software architecture. “Architectural programming” overcomes the problem of architectural erosion in implementations by integrating concepts of software architecture into programming languages. We present the new programming language Java/A as an instance for Java-based architectural programming and show how Java/A integrates architectural notions such as components, connectors, and assemblies into Java. A main asset of Java/A is its underlying abstract component model which provides the basis for reasoning about software components and assemblies. We give a formalisation of the abstract component model in terms of transition systems and states as algebras, and prove a consistency result for assemblies.

A formal semantics for UML interactions

The UML abstract syntax and semantics specification distinguishes between the statics and the dynamics of collaborations: the role context and interactions. We propose a formal semantics of interactions based on the abstract syntax and directly reflecting the specification. The semantics is both parametric in the notion of context and in semantic details that are intentionally left open by the specification, but resolves true inconsistencies. The formalisation uses temporal logic formulae in the style of Manna and Pnueli. We illustrate the flexibility of our semantics by discussing instantiations for a running example; its intuitiveness is substantiated by proving that the temporal formulae give rise to partial orders that also directly can be inferred from interactions.

Enhancing UML state machines with aspects

Separation of Concerns (SoC) is an important issue to reduce the complexity of software. Recent advances in programming language research show that Aspect-Oriented Programming (AOP) may be helpful for enhancing the SoC in software systems: AOP provides a means for describing concerns which are normally spread throughout the whole program at one location. The arguments for introducing aspects into programming languages also hold for modeling languages. In particular, modeling state-crosscutting behavior is insufficiently supported by UML state machines. This often leads to model elements addressing the same concern scattered all over the state machine. We present an approach to aspect-oriented state machines, which show considerably better modularity in modeling state-crosscutting behavior than standard UML state machines.