187,470 research outputs found
Session Types as Generic Process Types
Behavioural type systems ensure more than the usual safety guarantees of
static analysis. They are based on the idea of "types-as-processes", providing
dedicated type algebras for particular properties, ranging from protocol
compatibility to race-freedom, lock-freedom, or even responsiveness. Two
successful, although rather different, approaches, are session types and
process types. The former allows to specify and verify (distributed)
communication protocols using specific type (proof) systems; the latter allows
to infer from a system specification a process abstraction on which it is
simpler to verify properties, using a generic type (proof) system. What is the
relationship between these approaches? Can the generic one subsume the specific
one? At what price? And can the former be used as a compiler for the latter?
The work presented herein is a step towards answers to such questions.
Concretely, we define a stepwise encoding of a pi-calculus with sessions and
session types (the system of Gay and Hole) into a pi-calculus with process
types (the Generic Type System of Igarashi and Kobayashi). We encode session
type environments, polarities (which distinguish session channels end-points),
and labelled sums. We show forward and reverse operational correspondences for
the encodings, as well as typing correspondences. To faithfully encode session
subtyping in process types subtyping, one needs to add to the target language
record constructors and new subtyping rules. In conclusion, the programming
convenience of session types as protocol abstractions can be combined with the
simplicity and power of the pi-calculus, taking advantage in particular of the
framework provided by the Generic Type System.Comment: In Proceedings EXPRESS/SOS 2014, arXiv:1408.127
Context-Free Session Types for Applied Pi-Calculus
We present a binary session type system using context-free session types to a
version of the applied pi-calculus of Abadi et. al. where only base terms,
constants and channels can be sent. Session types resemble process terms from
BPA and we use a version of bisimulation equivalence to characterize type
equivalence. We present a quotiented type system defined on type equivalence
classes for which type equivalence is built into the type system. Both type
systems satisfy general soundness properties; this is established by an appeal
to a generic session type system for psi-calculi.Comment: In Proceedings EXPRESS/SOS 2018, arXiv:1808.0807
Frameworks: the future of formal software development?
It could be argued that the primary issue to be dealt with in software engineering today is re-use of software. Current software development rarely, if ever, starts from nothing. Unfortunately, the same cannot be said for the development of specifications. To overcome this problem, various works have attempted to show how specifications can be built using architectural principles. We discuss one such approach in particular, the Architectural Semantics of Open Distributed Processing. We show the limitations of this work with regard to the architecting of specifications and propose a new approach, based on frameworks. To highlight the approach we use the work currently being done in the TOSCA project in its development of a service creation and validation environment for telecommunication services
An instance of the MIKADO migration model
In this document, we briefly describe the main contribution to the deliverable on experimenting with the implementation of most of the calculi considered in the project. First, we describe how two well known calculi for mobile processes KLAIM and DÏ€ have been implemented on the top of IMC. We then describe the implementation of the MiKO programming language, an instance of the parametric calculus introduced in the WP1 with the TyCO calculus as the content of the membrane itself. After this, we outline the description of the implementation of the abstract machine for an instance of the Kell Calculus that dedicates particular attention to the proof of its correctness. Our presentation ends with a discussion of the problem of implementing security membranes on the top of an execution platform
Linearly Typed Dyadic Group Sessions for Building Multiparty Sessions
Traditionally, each party in a (dyadic or multiparty) session implements
exactly one role specified in the type of the session. We refer to this kind of
session as an individual session (i-session). As a generalization of i-session,
a group session (g-session) is one in which each party may implement a group of
roles based on one channel. In particular, each of the two parties involved in
a dyadic g-session implements either a group of roles or its complement. In
this paper, we present a formalization of g-sessions in a multi-threaded
lambda-calculus (MTLC) equipped with a linear type system, establishing for the
MTLC both type preservation and global progress. As this formulated MTLC can be
readily embedded into ATS, a full-fledged language with a functional
programming core that supports both dependent types (of DML-style) and linear
types, we obtain a direct implementation of linearly typed g-sessions in ATS.
The primary contribution of the paper lies in both of the identification of
g-sessions as a fundamental building block for multiparty sessions and the
theoretical development in support of this identification.Comment: This paper can be seen as the pre-sequel to classical linear
multirole logic (CLML). arXiv admin note: substantial text overlap with
arXiv:1603.0372
Type systems for distributed programs: session communication
Distributed systems are everywhere around us and guaranteeing their correctness is of paramount importance. It is natural to expect that these systems interact and communicate among them to achieve a common task.
In this work, we develop techniques based on types and type systems for the verification of correctness, consistency and safety properties related to communication in complex distributed systems. We study advanced safety properties related to communication, like deadlock or lock freedom and progress. We study session types in the pi-calculus describing distributed systems and communication-centric computation. Most importantly, we de- fine an encoding of the session pi-calculus into the standard typed pi-calculus in order to understand the expressive power of these concurrent calculi. We show how to derive in the session pi-calculus basic properties, like type safety or complex ones, like progress, by exploiting this encoding
Evaluation of Kermeta for Solving Graph-based Problems
Kermeta is a meta-language for specifying the structure and behavior of graphs of interconnected objects called models. In this paper,\ud
we show that Kermeta is relatively suitable for solving three graph-based\ud
problems. First, Kermeta allows the specification of generic model\ud
transformations such as refactorings that we apply to different metamodels\ud
including Ecore, Java, and Uml. Second, we demonstrate the extensibility\ud
of Kermeta to the formal language Alloy using an inter-language model\ud
transformation. Kermeta uses Alloy to generate recommendations for\ud
completing partially specified models. Third, we show that the Kermeta\ud
compiler achieves better execution time and memory performance compared\ud
to similar graph-based approaches using a common case study. The\ud
three solutions proposed for those graph-based problems and their\ud
evaluation with Kermeta according to the criteria of genericity,\ud
extensibility, and performance are the main contribution of the paper.\ud
Another contribution is the comparison of these solutions with those\ud
proposed by other graph-based tools
Systematic composition of distributed objects: Processes and sessions
We consider a system with the infrastructure for the creation and interconnection of large numbers of distributed persistent objects. This system is exemplified by the Internet: potentially, every appliance and document on the Internet has both persistent state and the ability to interact with large numbers of other appliances and documents on the Internet. This paper elucidates the characteristics of such a system, and proposes the compositional requirements of its corresponding infrastructure. We explore the problems of specifying, composing, reasoning about and implementing applications in such a system. A specific concern of our research is developing the infrastructure to support structuring distributed applications by using sequential, choice and parallel composition, in the anarchic environment where application compositions may be unforeseeable and interactions may be unknown prior to actually occurring. The structuring concepts discussed are relevant to a wide range of distributed applications; our implementation is illustrated with collaborative Java processes interacting over the Internet, but the methodology provided can be applied independent of specific platforms
- …