Alessandra Cavarra

An ASM Semantics for UML Activity Diagrams

We provide a rigorous semantics for one of the central diagram types which are used in UML for the description of dynamical system behavior, namely activity diagrams. We resolve for these diagrams some of the ambiguities which arise from difierent interpretations of UML models. Since we phrase our definition in terms of Abstract State Machines, we define at the same time an interesting subclass of ASMs, offering the possibility to exploit the UML tool support for using these special ASMs in the practice of software design. We apply these Activity Diagram Machines for a succinct definition of the semantics of OCCAM.

Modeling the Dynamics of UML State Machines

We define the dynamic semantics of UML State Machines which integrate statecharts with the UML object model. The use of ASMs allows us (a) to rigorously model the event driven run to completion scheme, including the sequential execution of entry/exit actions (along the structure of state nesting) and the concurrent execution of internal activities; (b) to formalize the object interaction, by combining control and data flow features in a seamless way; and (c) to provide a precise but nevertheless provably most general computational meaning to the UML terms of atomic and durative actions/activities. We borrow some features from the rigorous description of UML Activity Diagrams by ASMs in [7].

On formalizing UML state machines using ASMs

Abstract We present a transparent yet rigorous conceptual framework for defining the semantics of dynamic UML diagrams. We illustrate the method for UML state machines, making the “semantic variation points” of UML explicit, as well as various ambiguities and omissions in the official UML documents. This includes the event deferring and completion mechanism, the meaning of atomic and durative actions, concurrent internal activities and conflict situations which may arise through the concurrent behavior of active objects.

Formalizing Liveness−Enriched Sequence Diagrams Using ASMs

In UML 2.0 sequence diagrams have been considerably extended, influenced by Live Sequence Charts (LSCs), a very expressive extension of Message Sequence Charts (MSC) with liveness. Nonetheless, fundamental liveness properties can still not be expressed in the new sequence diagrams. In recent work, we have proposed to solve this by enriching sequence diagrams with a simple but powerful Object Constraint Language (OCL) template for liveness. In this paper, we show how to formalize our liveness-enriched sequence diagrams using Abstract State Machines.

Combining Sequence Diagrams and OCL for Liveness

Sequence diagrams in UML 2.0 have been considerably extended, partially influenced by variants of Message Sequence Charts (MSCs) and Live Sequence Charts (LSCs). However, sequence diagrams cannot satisfactorily express liveness/progress properties or differentiate between necessary and possible behaviour. To address this limitation, we propose to use an OCL template for liveness and enrich sequence diagrams with constraints as needed. We argue that our extended sequence diagrams are more expressive than LSCs. Further, if automatic code generation from inter-object behaviour specifications is feasible it will lead to more realistic solutions. Additionally, we discuss several problems and ambiguities in sequence diagrams as defined in the UML 2.0 superstructure specification. We discuss directions for future work.

On the generation of object databases using booster

This paper shows how ideas from a combination of formal techniques can be used to enable the automatic generation of databases from precise object models. It explores how the specification of an object database design can be formalized in terms of method preconditions, method postconditions, and invariant properties - many of which will correspond to integrity constraints for the data representation. Individual method specifications can be completed to reflect constraints expressed elsewhere in the model, composed to specify transactions, and then translated into executable code, to produce a reliable data store with a programming interface. The process of completion, composition, and translation may be automated to produce a model-driven approach to the development of object databases.

A framework to simulate UML models: moving from a semi-formal to a formal environment

This paper presents a simulation framework for UML models based upon a mapping schema of UML metamodel elements into Abstract State Machines (ASMs). Structural model elements are translated into an ASM vocabulary as collections of domains and functions, whereas the dynamic view is captured by multi-agent ASMs reflecting the behavior modeled by UML state machines.In the toolkit presented, input UML models can be drawn using any UML CASE Tool able to produce the XMI format for diagrams. This textual representation is exploited to initialize the ASM model for UML state machines which can be symbolically executed by AsmGofer, an advanced Abstract State Machine programming system.Tool features are described through the simulation of a simple stack-printer UML model showing the interactions among state machines by signals exchange and operation calls.

Integrating UML static and dynamic views and formalizing the interaction mechanism of UML state machines

In this paper we address the problem of integrating UML static and dynamic views, and different behavioral views. We tackle these problems by providing (a) a mapping of UML metamodel static and behavioral elements into ASMs and (b) a precise compositional semantics for UML state machines. Structural model elements are translated into an ASM vocabulary as collections of domains and functions. The dynamic view is captured by multi-agent ASMs reflecting the behavior modeled by UML state machines. The interaction among UML state machines is achieved by providing the semantics for actions and events and refining the ASM model in [4] to formalize objects communication, i.e. signals exchange and operation calls mechanism.

Data Flow Analysis and Testing of Abstract State Machines

This paper introduces an approach to apply data flow testing techniques to Abstract State Machines specifications. Since traditional data flow coverage criteria are strictly based on the mapping between a program and its flow graph, they cannot be directly applied to ASMs. In this context we are interested in tracing the flow of data between states in ASM runs as opposed to between nodes in a programs flow graph. Therefore, we revise the classical concepts in data flow analysis and define them on two levels: the syntactic (rule) level, and the computational (run) level. We also specify a family of ad hoc data flow coverage criteria and introduce a model checking-based approach to generate automatically test cases satisfying a given set of coverage criteria from ASM models.

Checking Model Consistency Using Data-Flow Testing

In model-driven development, requirements are captured as a specification model, from which a conforming implementation is automatically generated. Model consistency, with respect to requirements, is a primary concern. If the various structural and integrity constraints are inconsistent, then either the model will admit no implementation, or the implementation produced will not behave according to the intended requirements. We present an approach, based upon data-flow testing, to helping developers inspect their models for inconsistency. System models contain classes, attributes, invariants, and methods specified as first-order predicates. We identify for every attribute its intra-method usages. We construct accordingly call sequences demonstrating its inter-method usages. We derive from each call sequence a Boolean constraint, as a test case, ensuring both the execution of the corresponding inter-method usage and the maintenance of invariants. Developers may examine this test suite and compare against their original understandings about the requirements.