scholarly journals Mixed Sessions

2020 ◽  
pp. 715-742
Author(s):  
Vasco T. Vasconcelos ◽  
Filipe Casal ◽  
Bernardo Almeida ◽  
Andreia Mordido
Keyword(s):  
Program Development ◽  
Message Passing ◽  
Type System ◽  
The Other ◽  
Runtime System ◽  
Type Checking ◽  
Session Types ◽  
Patterns Of Interaction

AbstractSession types describe patterns of interaction on communicating channels. Traditional session types include a form of choice whereby servers offer a collection of options, of which each client picks exactly one. This sort of choice constitutes a particular case of separated choice: offering on one side, selecting on the other. We introduce mixed choices in the context of session types and argue that they increase the flexibility of program development at the same time that they reduce the number of synchronisation primitives to exactly one. We present a type system incorporating subtyping and prove preservation and absence of runtime errors for well-typed processes. We further show that classical (conventional) sessions can be faithfully and tightly embedded in mixed choices. Finally, we discuss algorithmic type checking and a runtime system built on top of a conventional (choice-less) message-passing architecture.

scholarly journals Nested Session Types

2021 ◽  
pp. 178-206
Author(s):  
Ankush Das ◽  
Henry DeYoung ◽  
Andreia Mordido ◽  
Frank Pfenning
Keyword(s):  
Programming Language ◽  
Message Passing ◽  
Communication Protocols ◽  
Type System ◽  
First Order ◽  
Session Types ◽  
Parametric Polymorphism ◽  
Trace Equivalence

AbstractSession types statically describe communication protocols between concurrent message-passing processes. Unfortunately, parametric polymorphism even in its restricted prenex form is not fully understood in the context of session types. In this paper, we present the metatheory of session types extended with prenex polymorphism and, as a result, nested recursive datatypes. Remarkably, we prove that type equality is decidable by exhibiting a reduction to trace equivalence of deterministic first-order grammars. Recognizing the high theoretical complexity of the latter, we also propose a novel type equality algorithm and prove its soundness. We observe that the algorithm is surprisingly efficient and, despite its incompleteness, sufficient for all our examples. We have implemented our ideas by extending the Rast programming language with nested session types. We conclude with several examples illustrating the expressivity of our enhanced type system.

A Lightweight Formalism for Reference Lifetimes and Borrowing in Rust

2021 ◽  
Vol 43 (1) ◽  
pp. 1-73
Author(s):  
David J. Pearce
Keyword(s):  
Memory Management ◽  
Programming Model ◽  
Type System ◽  
Control Flow ◽  
Two Phase ◽  
Type Checking ◽  
Strong Focus ◽  
Reference Implementation ◽  
Two Phases ◽  
Complex Features

Rust is a relatively new programming language that has gained significant traction since its v1.0 release in 2015. Rust aims to be a systems language that competes with C/C++. A claimed advantage of Rust is a strong focus on memory safety without garbage collection. This is primarily achieved through two concepts, namely, reference lifetimes and borrowing . Both of these are well-known ideas stemming from the literature on region-based memory management and linearity / uniqueness . Rust brings both of these ideas together to form a coherent programming model. Furthermore, Rust has a strong focus on stack-allocated data and, like C/C++ but unlike Java, permits references to local variables. Type checking in Rust can be viewed as a two-phase process: First, a traditional type checker operates in a flow-insensitive fashion; second, a borrow checker enforces an ownership invariant using a flow-sensitive analysis. In this article, we present a lightweight formalism that captures these two phases using a flow-sensitive type system that enforces “ type and borrow safety .” In particular, programs that are type and borrow safe will not attempt to dereference dangling pointers. Our calculus core captures many aspects of Rust, including copy- and move-semantics, mutable borrowing, reborrowing, partial moves, and lifetimes. In particular, it remains sufficiently lightweight to be easily digested and understood and, we argue, still captures the salient aspects of reference lifetimes and borrowing. Furthermore, extensions to the core can easily add more complex features (e.g., control-flow, tuples, method invocation). We provide a soundness proof to verify our key claims of the calculus. We also provide a reference implementation in Java with which we have model checked our calculus using over 500B input programs. We have also fuzz tested the Rust compiler using our calculus against 2B programs and, to date, found one confirmed compiler bug and several other possible issues.

scholarly journals Digital Citizens’ Feelings in National #Covid19 Campaigns in Spain

2021 ◽  
Author(s):  
Sonia Santoveña-Casal ◽  
Javier Gil-Quintana ◽  
Laura Ramos
Keyword(s):  
Quantitative Analysis ◽  
Citizen Participation ◽  
The Other ◽  
Occupational Groups ◽  
The Public ◽  
Entire Country ◽  
Research Goal ◽  
Health Situation ◽  
Patterns Of Interaction ◽  
Technical Measures

(1) Background: Spain launched an official campaign, #EsteVirusLoParamosUnidos, to try and unite the efforts of the entire country through citizen cooperation to combat coronavirus. The research goal is to analyze the Twitter campaign’s repercussion on general citizen feeling. (2) Methods: The research is based on a composite design that triangulates from a theoretical model, a quantitative analysis and a qualitative analysis. (3) Results: Of the 7357 tweets in the sample, 72.32% were found to be retweets. Four content families were extracted: politics, education, messages to society and defense of occupational groups. The feelings expressed ranged along a continuum, from unity, admiration and support at one end to discontent and criticism regarding the health situation at the other. (4) Conclusions: The development of networked sociopolitical and technical measures that enable citizen participation facilitates the development of new patterns of interaction between governments and digital citizens, increasing citizens’ possibilities of influencing the public agenda and therefore strengthening citizen engagement vis-à-vis such situations.

scholarly journals Characterization of MPI Communication Primitives on a Heterogeneous Cluster

2009 ◽  
Vol 6 (2) ◽  
pp. 23
Author(s):  
Siti Arpah Ahmad ◽  
Mohamed Faidz Mohamed Said ◽  
Norazan Mohamed Ramli ◽  
Mohd Nasir Taib
Keyword(s):  
Message Passing ◽  
High Performance ◽  
Data Transfer ◽  
The Other ◽  
Small Cluster ◽  
Heterogeneous Cluster ◽  
Processing Power ◽  
Basic Performance ◽  
Point To Point

This paper focuses on the performance of basic communication primitives, namely the overlap of message transfer with computation in the point-to-point communication within a small cluster of four nodes. The mpptest has been implemented to measure the basic performance of MPI message passing routines with a variety of message sizes. The mpptest is capable of measuring performance with many participating processes thus exposing contention and scalability problems. This enables programmers to select message sizes in order to isolate and evaluate sudden changes in performance. Investigating these matters is interesting in that non-blocking calls have the advantage of allowing the system to schedule communications even when many processes are running simultaneously. On the other hand, understanding the characteristics of computation and communication overlap is significant, because high- performance kernels often strive to achieve this, since it is both advantageous with respect to data transfer and latency hiding. The results indicate that certain overlap sizes utilize greater node processing power either in blocking send and receive operations or non-blocking send and receive operations. The results have elucidated a detailed MPI characterization of the performance regarding the overlap of message transfer with computation in a small cluster system. 

Coherence of subsumption, minimum typing and type-checking in F ≤

1992 ◽  
Vol 2 (1) ◽  
pp. 55-91 ◽  
Author(s):  
Pierre-Louis Curien ◽  
Giorgio Ghelli
Keyword(s):  
Normal Form ◽  
Type System ◽  
Lambda Calculus ◽  
Complete Information ◽  
Second Order ◽  
Semantic Interpretation ◽  
Type Checking ◽  
Rewriting System ◽  
Different Types ◽  
Rewriting Rules

A subtyping relation ≤ between types is often accompanied by a typing rule, called subsumption: if a term a has type T and T≤U, then a has type U. In presence of subsumption, a well-typed term does not codify its proof of well typing. Since a semantic interpretation is most naturally defined by induction on the structure of typing proofs, a problem of coherence arises: different typing proofs of the same term must have related meanings. We propose a proof-theoretical, rewriting approach to this problem. We focus on F≤, a second-order lambda calculus with bounded quantification, which is rich enough to make the problem interesting. We define a normalizing rewriting system on proofs, which transforms different proofs of the same typing judgement into a unique normal proof, with the further property that all the normal proofs assigning different types to a given term in a given environment differ only by a final application of the subsumption rule. This rewriting system is not defined on the proofs themselves but on the terms of an auxiliary type system, in which the terms carry complete information about their typing proof. This technique gives us three different results:— Any semantic interpretation is coherent if and only if our rewriting rules are satisfied as equations.— We obtain a proof of the existence of a minimum type for each term in a given environment.— From an analysis of the shape of normal form proofs, we obtain a deterministic typechecking algorithm, which is sound and complete by construction.

scholarly journals Global escape in multiparty sessions

2014 ◽  
Vol 26 (2) ◽  
pp. 156-205 ◽  
Author(s):  
SARA CAPECCHI ◽  
ELENA GIACHINO ◽  
NOBUKO YOSHIDA
Keyword(s):  
Type System ◽  
Error Handling ◽  
Escape Mechanism ◽  
Session Types ◽  
Liveness Properties ◽  
Model Complex

This article proposes a global escape mechanism which can handle unexpected or unwanted conditions changing the default execution of distributed communicational flows, preserving compatibility of the multiparty conversations. Our escape is realized by a collection of asynchronous local exceptions which can be thrown at any stage of the communication and to any subsets of participants in a multiparty session. This flexibility enables to model complex exceptions such as criss-crossing global interactions and error handling for distributed cooperating threads. Guided by multiparty session types, our semantics is proven to provide a termination algorithm for global escapes. Our type system guarantees further safety and liveness properties, such as progress within the session and atomicity of escapes with respect to the subset of involved participants.

scholarly journals PyCOMPSs: Parallel computational workflows in Python

2016 ◽  
Vol 31 (1) ◽  
pp. 66-82 ◽  
Author(s):  
Enric Tejedor ◽  
Yolanda Becerra ◽  
Guillem Alomar ◽  
Anna Queralt ◽  
Rosa M Badia ◽  
...  
Keyword(s):  
Data Storage ◽  
Message Passing ◽  
Programming Model ◽  
Runtime System ◽  
Data Dependencies ◽  
Parallel Tasks ◽  
Complete Set ◽  
Scientific Libraries ◽  
Python Programming ◽  
Big Data Storage

The use of the Python programming language for scientific computing has been gaining momentum in the last years. The fact that it is compact and readable and its complete set of scientific libraries are two important characteristics that favour its adoption. Nevertheless, Python still lacks a solution for easily parallelizing generic scripts on distributed infrastructures, since the current alternatives mostly require the use of APIs for message passing or are restricted to embarrassingly parallel computations. In that sense, this paper presents PyCOMPSs, a framework that facilitates the development of parallel computational workflows in Python. In this approach, the user programs her script in a sequential fashion and decorates the functions to be run as asynchronous parallel tasks. A runtime system is in charge of exploiting the inherent concurrency of the script, detecting the data dependencies between tasks and spawning them to the available resources. Furthermore, we show how this programming model can be built on top of a Big Data storage architecture, where the data stored in the backend is abstracted and accessed from the application in the form of persistent objects.

scholarly journals Deriving session and union types for objects

2013 ◽  
Vol 23 (6) ◽  
pp. 1163-1219
Author(s):  
LORENZO BETTINI ◽  
SARA CAPECCHI ◽  
MARIANGIOLA DEZANI-CIANCAGLINI ◽  
ELENA GIACHINO ◽  
BETTI VENNERI
Keyword(s):  
Large Scale ◽  
Type System ◽  
Object Oriented Programming ◽  
Type Safety ◽  
Network Applications ◽  
Session Types ◽  
Safety Property ◽  
Core Language ◽  
Structured Communication ◽  
Full Proof

Guaranteeing that the parties of a network application respect a given protocol is a crucial issue.Session typesoffer a method for abstracting and validating structured communication sequences (sessions).Object-oriented programmingis an established paradigm for large scale applications.Union types, which behave as the least common supertypes of a set of classes, allow the implementation of unrelated classes with similar interfaces without additional programming. We have previously developed an integration of the features above into a class-based core language for building network applications, and this successfully amalgamated sessions and methods so that data can be exchanged flexibly according to communication protocols (session types).The first aim of the work reported in this paper is to provide a full proof of the type safety property for that core language by renewing syntax, typing and semantics. In this way, static typechecking guarantees that after a session has started, computation cannot get stuck on a communication deadlock.The second aim is to define a constraint-based type system that reconstructs the appropriate session types of session declarations instead of assuming that session types are explicitly given by the programmer. Such an algorithm can save programming work, and automatically presents an abstract view of the communications of the sessions.

scholarly journals Skipping the binder bureaucracy with mixed embeddings in a semantics course (functional pearl)

2021 ◽  
Vol 5 (ICFP) ◽  
pp. 1-28
Author(s):  
Adam Chlipala
Keyword(s):  
Order Reduction ◽  
Separation Logic ◽  
Variable Binding ◽  
Type Checking ◽  
Session Types ◽  
The Coq Proof Assistant ◽  
Reduction Program ◽  
Coq Proof Assistant ◽  
Big Ideas ◽  
Concurrent Separation Logic

Rigorous reasoning about programs calls for some amount of bureaucracy in managing details like variable binding, but, in guiding students through big ideas in semantics, we might hope to minimize the overhead. We describe our experiment introducing a range of such ideas, using the Coq proof assistant, without any explicit representation of variables, instead using a higher-order syntax encoding that we dub "mixed embedding": it is neither the fully explicit syntax of deep embeddings nor the syntax-free programming of shallow embeddings. Marquee examples include different takes on concurrency reasoning, including in the traditions of model checking (partial-order reduction), program logics (concurrent separation logic), and type checking (session types) -- all presented without any side conditions on variables.

Sign in / Sign up

Export Citation Format

Share Document