209 research outputs found
Dynamic Choreographies - Safe Runtime Updates of Distributed Applications
Programming distributed applications free from communication deadlocks and
races is complex. Preserving these properties when applications are updated at
runtime is even harder. We present DIOC, a language for programming distributed
applications that are free from deadlocks and races by construction. A DIOC
program describes a whole distributed application as a unique entity
(choreography). DIOC allows the programmer to specify which parts of the
application can be updated. At runtime, these parts may be replaced by new DIOC
fragments from outside the application. DIOC programs are compiled, generating
code for each site, in a lower-level language called DPOC. We formalise both
DIOC and DPOC semantics as labelled transition systems and prove the
correctness of the compilation as a trace equivalence result. As corollaries,
DPOC applications are free from communication deadlocks and races, even in
presence of runtime updates.Comment: Technical Repor
Dynamic Choreographies Safe Runtime Updates of Distributed Applications.
Programming distributed applications free from communication deadlocks and races is complex. Preserving these properties whenapplications are updated at runtime is even harder. We present DIOC, a language for programming distributed applications that are free from deadlocks and races by construction. A DIOC program describes a whole distributed application as a unique entity (choreography).DIOC allows the programmer to specify which parts of the application can be updated. At runtime, these parts may be replaced by new DIOC fragments from outside the application. DIOC programs are compiled, generating code for each site, in a lower-level language called DPOC. We formalise both DIOC and DPOC semantics as labelled transition systems and prove the correctness of the compilation as a trace equivalence result. As corollaries, DPOC applications are free from communication deadlocks and races, even in presence of runtime updates
Dynamic Choreographies: Theory And Implementation
Programming distributed applications free from communication deadlocks and
race conditions is complex. Preserving these properties when applications are
updated at runtime is even harder. We present a choreographic approach for
programming updatable, distributed applications. We define a choreography
language, called Dynamic Interaction-Oriented Choreography (AIOC), that allows
the programmer to specify, from a global viewpoint, which parts of the
application can be updated. At runtime, these parts may be replaced by new AIOC
fragments from outside the application. AIOC programs are compiled, generating
code for each participant in a process-level language called Dynamic
Process-Oriented Choreographies (APOC). We prove that APOC distributed
applications generated from AIOC specifications are deadlock free and race free
and that these properties hold also after any runtime update. We instantiate
the theoretical model above into a programming framework called Adaptable
Interaction-Oriented Choreographies in Jolie (AIOCJ) that comprises an
integrated development environment, a compiler from an extension of AIOCs to
distributed Jolie programs, and a runtime environment to support their
execution.Comment: arXiv admin note: text overlap with arXiv:1407.097
On Asynchrony and Choreographies
Choreographic Programming is a paradigm for the development of concurrent
software, where deadlocks are prevented syntactically. However, choreography
languages are typically synchronous, whereas many real-world systems have
asynchronous communications. Previous attempts at enriching choreographies with
asynchrony rely on ad-hoc constructions, whose adequacy is only argued
informally. In this work, we formalise the properties that an asynchronous
semantics for choreographies should have: messages can be sent without the
intended receiver being ready, and all sent messages are eventually received.
We explore how out-of-order execution, used in choreographies for modelling
concurrency, can be exploited to endow choreographies with an asynchronous
semantics. Our approach satisfies the properties we identified. We show how our
development yields a pleasant correspondence with FIFO-based asynchronous
messaging, modelled in a process calculus, and discuss how it can be adopted in
more complex choreography models.Comment: In Proceedings ICE 2017, arXiv:1711.1070
The Paths to Choreography Extraction
Choreographies are global descriptions of interactions among concurrent
components, most notably used in the settings of verification (e.g., Multiparty
Session Types) and synthesis of correct-by-construction software (Choreographic
Programming). They require a top-down approach: programmers first write
choreographies, and then use them to verify or synthesize their programs.
However, most existing software does not come with choreographies yet, which
prevents their application.
To attack this problem, we propose a novel methodology (called choreography
extraction) that, given a set of programs or protocol specifications,
automatically constructs a choreography that describes their behavior. The key
to our extraction is identifying a set of paths in a graph that represents the
symbolic execution of the programs of interest. Our method improves on previous
work in several directions: we can now deal with programs that are equipped
with a state and internal computation capabilities; time complexity is
dramatically better; we capture programs that are correct but not necessarily
synchronizable, i.e., they work because they exploit asynchronous
communication
Guess Who\u2019s Coming: Runtime Inclusion of Participants in Choreographies
In Choreographic Programming, a choreography specifies in a single artefact the expected behaviour of all the participants in a distributed system. The choreography is used to synthesise correct-by-construction programs for each participant. In previous work, we defined Dynamic Choreographies to support the update of distributed systems at runtime. In this work, we extend Dynamic Choreographies to include new participants at runtime, capturing those use cases where the system might be updated to interact with new, unforeseen stakeholders. We formalise our extension, prove its correctness, and present an implementation in the AIOCJ choreographic framework
Choreographies in Practice
Choreographic Programming is a development methodology for concurrent
software that guarantees correctness by construction. The key to this paradigm
is to disallow mismatched I/O operations in programs, called choreographies,
and then mechanically synthesise distributed implementations in terms of
standard process models via a mechanism known as EndPoint Projection (EPP).
Despite the promise of choreographic programming, there is still a lack of
practical evaluations that illustrate the applicability of choreographies to
concrete computational problems with standard concurrent solutions. In this
work, we explore the potential of choreographies by using Procedural
Choreographies (PC), a model that we recently proposed, to write distributed
algorithms for sorting (Quicksort), solving linear equations (Gaussian
elimination), and computing Fast Fourier Transform. We discuss the lessons
learned from this experiment, giving possible directions for the usage and
future improvements of choreography languages
Programming adaptive microservice applications: An AIOCJ tutorial
This tutorial describes AIOCJ, which stands for Adaptive Interaction Oriented Choreographies in Jolie, a choreographic language for programming microservice-based applications which can be updated at runtime. The compilation of a single AIOCJ program generates the whole set of distributed microservices that compose the application. Adaptation is performed using adaptation rules. Abstractly, each rule replaces a pre-delimited part of the program with the new code contained in the rule itself. Concretely, at runtime, the application of a rule updates part of the microservices that compose the application so to match the behavior specified by the updated program.
Thanks to the properties of choreographies, the adaptive application is free from communication deadlocks and message races even after adaptation
Behavioral types in programming languages
A recent trend in programming language research is to use behav- ioral type theory to ensure various correctness properties of large- scale, communication-intensive systems. Behavioral types encompass concepts such as interfaces, communication protocols, contracts, and choreography. The successful application of behavioral types requires a solid understanding of several practical aspects, from their represen- tation in a concrete programming language, to their integration with other programming constructs such as methods and functions, to de- sign and monitoring methodologies that take behaviors into account. This survey provides an overview of the state of the art of these aspects, which we summarize as the pragmatics of behavioral types
- …