Laura Semini

StPowla: SOA, Policies and Workflows

We introduce StPowla , a workflow based approach to business process modelling that integrates a simple graphical notation, to ease the presentation of the core business process, a user---friendly policy language, Appel , to provide the necessary adaptation to the varied expectations of the various business stakeholders, and the Service Oriented Architecture, to assemble and orchestrate available services in the business process. We illustrate the approach with a loan approval process.

Logic-based detection of conflicts in APPEL policies

APPEL is a general language for expressing policies in a variety of application domains with a clear separation between the core language and its specialisation for concrete domains. Policies can conflict, thus leading to undesired behaviour. We present a novel formal semantics for the Appel language based on ΔDSTL(x) (so far APPEL only had an informal semantics). ΔDSTL(x) is an extension of temporal logic to deal with global applications: it includes modalities to localize properties to system components, an operator to deal with events, and temporal modalities à la Unity. A further contribution of the paper is the development of techniques based on the semantics to reason about conflicts.

Mark, a Reasoning Kit for Mobility

The experience gained to date in the development of network applications has shown the difficulties of using traditional software technologies: reasoning about network applications is subtly different from reasoning about ordinary programs because of stronger requirements on security, different forms of termination, and phenomena like mobility and network-awareness. There are currently no standard methods, techniques and tools to support specification, development and (property) certification of these applications. To support property certification of network applications, we propose to use the network-aware logic Mobadtl and its proof assistant, Mark (Mobadtl Reasoning Kit). In the paper we present the prototype implementation of Mark and, as a validating example, we consider applications where mobile components are allowed to carry some resources with them when moving around the network.

Distributed states logic

We introduce a temporal logic to reason on global applications. First, we define a modal logic for localities that embeds the local theories of each component into a theory of the distributed states of the system. We provide the logic with a sound and complete axiomatization. Then, we extend the logic with a temporal operator. The contribution is that it is possible to reason about properties that involve several components in a natural way, even in the absence of a global clock, as required in an asynchronous setting.

Mobile Agents Coordination in Mobadtl

We present and formalize Mobadtl, a model for network-aware applications, extending the Oikos-adtl temporal-logic based approach to the specification and verification of distributed systems. The model supports strong subjective mobility of agents under the control of stationary guardians. Communications are based on asynchronous message passing. The approach exploits the notions of coordination and refinement to deal separately with the specification of functional issues in the agents, and with the specification of coordination policies, e.g. security, routing, etc., in the guardians. The goal is to specify mobile agents as independently as possible of the requirements related to the other facets of distribution. The specification of an application is obtained by instantiating the general model, refining it along different dimensions corresponding to the different aspects of interest, and finally composing the refinements. The main advantage, besides the increased flexibility of the specification process, is that it is possible to specify rich coordination policies incrementally, while the functional units remain relatively simple. We use Mobadtl to specify a simple electronic commerce application, paying particular attention to the incremental specification of the policies. We show how refined policies lead to stronger system properties.

A logical view of choreography

We present a model for choreography a la WS–CDL and formalize it in ΔDSTL(x), a spatio–temporal logic for the specification and verification of global computing systems. The approach builds on the formalization of an atomic interaction and defines composition rules to describe complex choreographies. The logic permits to reason on the choreography formalization and to derive the properties of interest. A pleasant characteristics of the proposed approach is that the composition of formulae, corresponding to a choreography, results in a formula shaping as an atomic interaction formula. Therefore, the properties of complex choreographies can be uniformly described as interactions. We demonstrate the approach using a business scenario already tackled in the literature.

A Refinement Calculus for Tuple Spaces

It is fairly accepted that the realization of complex systems must be accomplished step by step from the initial specification, through a sequence of intermediate phases, to the final program. These development steps, linking a preliminary version, or description, of the program to a more detailed one, are usually called refinement steps, while the intermediate stages of a refinement process are called levels of abstraction. A refinement calculus is a means to support this modus operandi in program development, allowing to link different levels of abstraction: it introduces a precise relation between intermediate descriptions, and the rules to check whether the relation is satisfied. Tuple space languages are concurrent languages, that foster the definition of autonomous entities of computation (the processes), and offer mechanisms for their synchronization and communication. In particular, they represent one of the most acknowledged models of coordination. Tuple space languages are based on the idea that a dynamic collection of tuples can act as shared state of concurrent processes, and play the role of coordination media among them. To build a refinement calculus for tuple spaces, we address three points, in this paper: 1) We single out a specification language, a variation of first order temporal logic. Temporal relations between propositional formulae are not expressive enough to describe relations between tuple spaces, which are multisets of atoms. The specification language, called Oikos-tl, includes three new temporal operators that enhance the expressive power of the logic, permitting to directly link state transitions and state configurations. The semantics of the specification language is formally defined, and a set of useful properties for refinement are shown. 2) We introduce a reference language for tuple spaces, dubbed TuSpRel, and define its axiomatic and operational semantics. We need the former to derive properties, the latter to describe the allowed computations of a system. We relate these descriptions, and guarantee that using the axiomatic semantics we can derive properties, which are correct and complete with respect to the operational behaviour. The non-deterministic features of tuple space languages make this result new, and more complex than in other programming paradigms. One of the contributions of our work is the idea to derive weakest preconditions exploiting the demonic strict choice in non-deterministic selection. The transition system defining the operational semantics is based on the new notion of enabling precondition, which exploits the angelic strict choice. 3) To build the refinement calculus, we take a compositional approach. We first consider the basic statements of the language, and say under which conditions they satisfy a property, then compose these proofs to derive that a system refines a specification. Finally, in the refinement calculus definition, we extend to tuple space languages the ability to exp

Logic Based Coordination for Event-Driven Self-Healing Distributed Systems

The ability to deal with events explicitely may enhance the expressivity and simplicity of logical specifications. To this purpose, we explore the use of events in the context of DSTL, a logic tailored for the description and verification of distributed systems in a setting based on asynchronous communications. We define an extension that allows the engineer to mix conditions and events in the specification formulae. To validate our approach we formalize a complex coordination pattern where the events play a central role. The pattern describes the rules a set of components must follow to self–organize in a token–ring.

Composing Specications for Coordination

We introduce Oikos_adtl, a specification language for distributed systems based on asynchronous communication via remote writings. The language is designed to support the composition of specifications. It allows expressing the global properties of a system in terms of the local properties of the components and of coordination templates. Oikos_adtl is based on an asynchronous, distributed, temporal logic, which extends Unity to deal with components and events. We present the specification language and its semantics, introduce a number of compositionality theorems, and discuss some coordination templates. A fragment of a standard case study is used to validate pragmatically the approach, with respect to expressiveness and work-ability.

Refining by architectural styles or architecting by refinements

System development by refinements provides a number ofadvantages, notably correct derivation and documentation of design decisions. In this paper, we illustrate this position by introducing some refinement patterns that correspond to well known architectural styles: The application of a pattern in the development both guarantees the correctness of the step, and makes the architecture explicit.