Gianluigi Zavattaro

SOCK: a calculus for service oriented computing

Service oriented computing is an emerging paradigm for designing distributed applications where service and composition are the main concepts it is based upon. In this paper we propose SOCK, a three-layered calculus equipped with a formal semantics, for addressing all the basic mechanisms of service communication and composition. The main contribute of our work is the development of a formal framework where the service design is decomposed into three fundamental parts: the behaviour, the declaration and the composition where each part can be designed independently of the other ones.

A Calculus for Long-Running Transactions

We study long-running transactions in open component-based distributed applications, such as Web Services platforms. Long-running transactions describe time-extensive activities that involve several distributed components. Henceforth, in case of failure, it is usually not possible to restore the initial state, and firing a compensation process is preferable. Despite the interest of such transactional mechanisms, a formal modeling of them is still lacking. In this paper we address this issue by designing an extension of the asynchronous π-calculus with long-running transactions (and sequences) – the πt -calculus. We study the practice of πt-calculus, by discussing few paradigmatic examples, and its theory, by defining a semantics and providing a correct encoding of πt-calculus into asynchronous π-calculus.

SCC: a service centered calculus

We seek for a small set of primitives that might serve as a basis for formalising and programming service oriented applications over global computers. As an outcome of this study we introduce here SCC, a process calculus that features explicit notions of service definition, service invocation and session handling. Our proposal has been influenced by Orc, a programming model for structured orchestration of services, but the SCCs session handling mechanism allows for the definition of structured interaction protocols, more complex than the basic request-response provided by Orc. We present syntax and operational semantics of SCC and a number of simple but nontrivial programming examples that demonstrate flexibility of the chosen set of primitives. A few encodings are also provided to relate our proposal with existing ones.

Foundations of web transactions

A timed extension of π-calculus with a transaction construct – the calculus Webπ – is studied. The underlying model of Webπ relies on networks of processes; time proceeds asynchronously at the network level, while it is constrained by the local urgency at the process level. Namely process reductions cannot be delayed to favour idle steps. The extensional model – the timed bisimilarity – copes with time and asynchrony in a different way with respect to previous proposals. In particular, the discriminating power of timed bisimilarity is weaker when local urgency is dropped. A labelled characterization of timed bisimilarity is also discussed.

CONCUR 2009 - Concurrency Theory

Invited Papers.- Perspectives on Transactional Memory.- The Effect of Tossing Coins in Omega-Automata.- Bigraphical Categories.- BlenX Static and Dynamic Semantics.- Contributed Papers.- Flow Policy Awareness for Distributed Mobile Code.- Volume and Entropy of Regular Timed Languages: Discretization Approach.- A Logical Interpretation of the ?-Calculus into the ?-Calculus, Preserving Spine Reduction and Types.- Encoding Asynchronous Interactions Using Open Petri Nets.- Distributed Asynchronous Automata.- Algebra for Infinite Forests with an Application to the Temporal Logic EF.- Deriving Syntax and Axioms for Quantitative Regular Behaviours.- Weighted Bisimulation in Linear Algebraic Form.- A Logic-Based Framework for Reasoning about Composite Data Structures.- Measuring Permissivity in Finite Games.- Contracts for Mobile Processes.- Power of Randomization in Automata on Infinite Strings.- Probabilistic Weighted Automata.- Partially-Commutative Context-Free Processes.- Testing Finitary Probabilistic Processes.- A Demonic Approach to Information in Probabilistic Systems.- HYPE: A Process Algebra for Compositional Flows and Emergent Behaviour.- Variable Binding, Symmetric Monoidal Closed Theories, and Bigraphs.- Partial Order Reduction for Probabilistic Systems: A Revision for Distributed Schedulers.- Model-Checking Games for Fixpoint Logics with Partial Order Models.- Reachability in Succinct and Parametric One-Counter Automata.- Winning Regions of Pushdown Parity Games: A Saturation Method.- Concurrent Kleene Algebra.- Concavely-Priced Probabilistic Timed Automata.- Compositional Control Synthesis for Partially Observable Systems.- Howes Method for Calculi with Passivation.- On the Relationship between ?-Calculus and Finite Place/Transition Petri Nets.- Modeling Radio Networks.- Time-Bounded Verification.- Secure Enforcement for Global Process Specifications.- On Convergence of Concurrent Systems under Regular Interactions.- Computing Stuttering Simulations.- Weak Time Petri Nets Strike Back!.- A General Testability Theory.- Counterexamples in Probabilistic LTL Model Checking for Markov Chains.- Query-Based Model Checking of Ad Hoc Network Protocols.- Strict Divergence for Probabilistic Timed Automata.

Choreography and orchestration: a synergic approach for system design

Choreography and orchestration languages deal with business processes design and specification. Referring to Web Services technology, the most credited proposals are WS-CDL about choreography and WS-BPEL about orchestration. A closer look to such a kind of languages highlights two distinct approaches for system representation and management. Choreography describes the system in a top view manner whereas orchestration focuses on single peers description. In this paper we define a notion of conformance between choreography and orchestration which allows to state when an orchestrated system is conformant to a given choreography. Choreography and orchestration are formalized by using two process algebras and conformance takes the form of a bisimulation-like relation.

A process algebraic view of Linda coordination primitives

The main Linda coordination primitives (asynchronous communication, read operation, nonblocking in/rd predicates) are studied in a process algebraic setting. A lattice of eight languages is proposed, where its bottom element L is a process algebra differing from CCS only for the asynchrony of the output operation, while all the other languages in the lattice are obtained as extension of this basic language by adding some of the Linda coordination primitives. The observational semantics for these languages are all obtained as the coarsest congruences contained in the barbed semantics, where only tuples are observable. The lattice of the eight languages collapses to a smaller four-points lattice of different bisimulation-based semantics. Notably, for L this semantics is the standard notion of strong bisimulation, where inputs and outputs/tuples are treated symmetrically.

On the expressiveness of Linda coordination primitives

We introduce a process algebra containing the coordination primitives of Linda (asynchronous communication via a shared data space, read operation, nonblocking test operators on the shared space). We compare two possible semantics for the output operation: the former, that we call ordered, defines the output as an operation that returns when the message has reached the shared data space; the latter, that we call unordered, returns just after sending the message to the tuple space. The process algebra under the ordered semantics is Turing powerful, as we are able to program any random access machine. The main result of the paper is that the process algebra under the unordered semantics is not Turing powerful. This result is achieved by resorting to a net semantics in terms of contextual nets (P/T nets with inhibitor and read arcs) and by showing that there exists a deadlock-preserving simulation of such nets by finite P/T nets, a formalism where termination is decidable.

Contract based multi-party service composition

In the context of Service Oriented Computing, contracts are descriptions of the observable behaviour of services. Contracts have been already successfully exploited to solve the problem of client/service composition. In this paper we consider services where the choice to perform an output may not depend on the environment and we revisit the theory of contracts in order to tackle the problem of composition of multiple services (not only one client with one service). Moreover, we relate our theory of contracts with the theory of testing preorder (interpreted as a subcontract relation) and we show that a compliant group of contracts is still compliant if every contract is replaced by one of its subcontract.

Bridging the Gap between Interaction- and Process-Oriented Choreographies

In service oriented computing, choreography languages are used to specify multi-party service compositions. Two main approaches have been followed: the interaction-oriented approach of WS-CDL and the process-oriented approach of BPEL4Chor. We investigate the relationship between them. In particular, we consider several interpretations for interaction-oriented choreographies spanning from synchronous to asynchronous communication. Under each of these interpretations we characterize the class of interaction-oriented choreographies which have a process-oriented counterpart, and we formalize the notion of equivalence between the initial interaction-oriented choreography and the corresponding process-oriented one.