A Graphical Approach to Progress for Structured Communication in Web Services

@inproceedings{Carbone2010AGA,
  title={A Graphical Approach to Progress for Structured Communication in Web Services},
  author={Marco Carbone and S{\o}ren Debois},
  booktitle={ICE},
  year={2010}
}
We investigate a graphical representation of session invocation interdependency in order to prove progress for the pi-calculus with sessions under the usual session typing discipline. We show that those processes whose associated dependency graph is acyclic can be brought to reduce. We call such processes transparent processes. Additionally, we prove that for well-typed processes where services contain no free names, such acyclicity is preserved by the reduction semantics. Our results… 

Figures and Tables from this paper

Session Types with Runtime Adaptation: Overview and Examples

The aim is to understand whether known techniques for the static analysis of structured communications scale up to the challenging context of context-aware, adaptable distributed systems, in which disciplined interaction and runtime adaptation are intertwined concerns.

A Semantics for Propositions as Sessions

A variant of Wadler’s session-typed core functional language, GV, is presented and a small-step operational semantics for GV is given, which defines two extensions of GV which preserve deadlock-freedom, determinism, and termination.

Inference of Global Progress Properties for Dynamically Interleaved Multiparty Sessions

This paper develops a static analysis technique, specified as a set of syntax-directed inference rules, that is capable of verifying whether a system of processes engaged in simultaneously active multiparty sessions has the progress property.

Type Systems for Distributed Programs: Session Communication

This work develops techniques based on types and type systems for the verification of correctness, consistency and safety properties related to communication in complex distributed systems.

Type-checking Liveness for Collaborative Processes with Bounded and Unbounded Recursion

This work presents the first session typing system guaranteeing response liveness properties for possibly non-terminating communicating processes, and proves that this type system is sound, i.e., it guarantees request-response liveness for dead-lock free processes.

Multiparty session types as coherence proofs

A Curry–Howard correspondence between a language for programming multiparty sessions and a generalisation of Classical Linear Logic, which generalise the cut rule of CLL to a new rule for composing many processes communicating in a multiparty session is proposed.

Progress as Compositional Lock-Freedom

A conservative extension of catalysers that does not depend on types is developed, generalising the notion of progress to untyped session-based processes and leads to a novel characterisation of progress in terms of the standard notion of lock-freedom.

Session Types in a Linearly Typed Multi-Threaded Lambda-Calculus

This paper reports an implementation ready for practical use that generates Erlang code from well-typed ATS source (making use of session types), thus taking great advantage of the infrastructural support for distributed computing in Erlang.

Comparing Deadlock-Free Session Typed Processes

This paper compares L and K, two classes of deadlock-free, session typed concurrent processes, and shows that L is strictly included in K, and provides a type-preserving rewriting procedure of processes in K into processes in L.

References

SHOWING 1-10 OF 20 REFERENCES

On Progress for Structured Communications

We propose a new typing system for the π-calculus with sessions, which ensures the progress property, i.e. once a session has been initiated, typable processes will never starve at session channels.

Session-Based Distributed Programming in Java

This paper presents the first full implementation of a language and runtime for session-based distributed programming featuring asynchronous message passing, delegation, and session subtyping and interleaving, combined with class downloading and failure handling in Java.

Session Types for Object-Oriented Languages

This work describes the design of Moose, its syntax, operational semantics and type system, and develops a type inference system that establishes the progress property: once a communication has been established, well-typed programs will never starve at communication points.

Asynchronous Session Types and Progress for Object Oriented Languages

This paper first formulate a typed asynchronous multi-threaded object-oriented language with thread spawning, iterative and higher order sessions, and studies its progress through a new effect system, believed to be the first session type system which assures progress in asynchronous communication.

Structured Communication-Centered Programming for Web Services

This article relates two different paradigms of descriptions of communication behavior, one focusing on global message flows and another on end-point behaviors, using formal calculi based on session types, to explore a theory of end- Point projection, by which a global description is mapped to its end- point counterparts preserving types and dynamics.

Language Primitives and Type Discipline for Structured Communication-Based Programming

Basic language constructs and a type discipline are introduced as a foundation of structured communication-based concurrent programming, which offers a high-level type abstraction of interactive behaviours of programs as well as guaranteeing the compatibility of interaction patterns between processes in a well-typed program.

A Type System for Client Progress in a Service-Oriented Calculus

In a well-typed CaSPiS system, and in absence of divergence, any client invoking a service is guaranteed not to get stuck during the execution of a conversation protocol because of inadequate service communication capabilities.

An Interaction-based Language and its Typing System

The language is given formal operational semantics and a type inference system, regarding which it is proved that if a program is well-typed in the typing system, it never causes run-time error due to type inconsistent communication patterns.

Conversation types