7,093 research outputs found
Session Types for Broadcasting
Up to now session types have been used under the assumptions of point to
point communication, to ensure the linearity of session endpoints, and reliable
communication, to ensure send/receive duality. In this paper we define a
session type theory for broadcast communication semantics that by definition do
not assume point to point and reliable communication. Our session framework
lies on top of the parametric framework of broadcasting psi-calculi, giving
insights on developing session types within a parametric framework. Our session
type theory enjoys the properties of soundness and safety. We further believe
that the solutions proposed will eventually provide a deeper understanding of
how session types principles should be applied in the general case of
communication semantics.Comment: In Proceedings PLACES 2014, arXiv:1406.331
A type checking algorithm for qualified session types
We present a type checking algorithm for establishing a session-based
discipline in the pi calculus of Milner, Parrow and Walker. Our session types
are qualified as linear or unrestricted. Linearly typed communication channels
are guaranteed to occur in exactly one thread, possibly multiple times;
afterwards they evolve as unrestricted channels. Session protocols are
described by a type constructor that denotes the two ends of one and the same
communication channel. We ensure the soundness of the algorithm by showing that
processes consuming all linear resources are accepted by a type system
preserving typings during the computation and that type checking is consistent
w.r.t. structural congruence.Comment: In Proceedings WWV 2011, arXiv:1108.208
Typing Copyless Message Passing
We present a calculus that models a form of process interaction based on
copyless message passing, in the style of Singularity OS. The calculus is
equipped with a type system ensuring that well-typed processes are free from
memory faults, memory leaks, and communication errors. The type system is
essentially linear, but we show that linearity alone is inadequate, because it
leaves room for scenarios where well-typed processes leak significant amounts
of memory. We address these problems basing the type system upon an original
variant of session types.Comment: 50 page
Causal Consistency for Reversible Multiparty Protocols
In programming models with a reversible semantics, computational steps can be
undone. This paper addresses the integration of reversible semantics into
process languages for communication-centric systems equipped with behavioral
types. In prior work, we introduced a monitors-as-memories approach to
seamlessly integrate reversible semantics into a process model in which
concurrency is governed by session types (a class of behavioral types),
covering binary (two-party) protocols with synchronous communication. The
applicability and expressiveness of the binary setting, however, is limited.
Here we extend our approach, and use it to define reversible semantics for an
expressive process model that accounts for multiparty (n-party) protocols,
asynchronous communication, decoupled rollbacks, and abstraction passing. As
main result, we prove that our reversible semantics for multiparty protocols is
causally-consistent. A key technical ingredient in our developments is an
alternative reversible semantics with atomic rollbacks, which is conceptually
simple and is shown to characterize decoupled rollbacks.Comment: Extended, revised version of a PPDP'17 paper
(https://doi.org/10.1145/3131851.3131864
Kickstarting Choreographic Programming
We present an overview of some recent efforts aimed at the development of
Choreographic Programming, a programming paradigm for the production of
concurrent software that is guaranteed to be correct by construction from
global descriptions of communication behaviour
Behavioural Types for Actor Systems
Recent mainstream programming languages such as Erlang or Scala have renewed
the interest on the Actor model of concurrency. However, the literature on the
static analysis of actor systems is still lacking of mature formal methods. In
this paper we present a minimal actor calculus that takes as primitive the
basic constructs of Scala's Actors API. More precisely, actors can send
asynchronous messages, process received messages according to a pattern
matching mechanism, and dynamically create new actors, whose scope can be
extruded by passing actor names as message parameters. Drawing inspiration from
the linear types and session type theories developed for process calculi, we
put forward a behavioural type system that addresses the key issues of an actor
calculus. We then study a safety property dealing with the determinism of
finite actor com- munication. More precisely, we show that well typed and
balanced actor systems are (i) deadlock-free and (ii) any message will
eventually be handled by the target actor, and dually no actor will
indefinitely wait for an expected messag
Combining behavioural types with security analysis
Today's software systems are highly distributed and interconnected, and they
increasingly rely on communication to achieve their goals; due to their
societal importance, security and trustworthiness are crucial aspects for the
correctness of these systems. Behavioural types, which extend data types by
describing also the structured behaviour of programs, are a widely studied
approach to the enforcement of correctness properties in communicating systems.
This paper offers a unified overview of proposals based on behavioural types
which are aimed at the analysis of security properties
- …