507 research outputs found
Multiparty Session Actors
Actor coordination armoured with a suitable protocol description language has
been a pressing problem in the actors community. We study the applicability of
multiparty session type (MPST) protocols for verification of actor programs. We
incorporate sessions to actors by introducing minimum additions to the model
such as the notion of actor roles and protocol mailbox. The framework uses
Scribble, which is a protocol description language based on multiparty session
types. Our programming model supports actor-like syntax and runtime
verification mechanism guaranteeing type-safety and progress of the
communicating entities. An actor can implement multiple roles in a similar way
as an object can implement multiple interfaces. Multiple roles allow for
inter-concurrency in a single actor still preserving its progress property. We
demonstrate our framework by designing and implementing a session actor library
in Python and its runtime verification mechanism.Comment: In Proceedings PLACES 2014, arXiv:1406.331
Towards Reversible Sessions
In this work, we incorporate reversibility into structured
communication-based programming, to allow parties of a session to automatically
undo, in a rollback fashion, the effect of previously executed interactions.
This permits taking different computation paths along the same session, as well
as reverting the whole session and starting a new one. Our aim is to define a
theoretical basis for examining the interplay in concurrent systems between
reversible computation and session-based interaction. We thus enrich a
session-based variant of pi-calculus with memory devices, dedicated to keep
track of the computation history of sessions in order to reverse it. We discuss
our initial investigation concerning the definition of a session type
discipline for the proposed reversible calculus, and its practical advantages
for static verification of safe composition in communication-centric
distributed software performing reversible computations.Comment: In Proceedings PLACES 2014, arXiv:1406.331
Molecular mechanisms of Trypanosoma cruzi infection by oral route
Frequent reports on outbreaks of acute Chagas' disease by ingestion of food contaminated with parasites from triatomine insects illustrate the importance of this mode of transmission. Studies on oral Trypanosoma cruzi infection in mice have indicated that metacyclic trypomastigotes invade the gastric mucosal epithelium. A key molecule in this process is gp82, a stage-specific surface glycoprotein that binds to both gastric mucin and to target epithelial cells. By triggering Ca2+ signalling, gp82 promotes parasite internalisation. Gp82 is relatively resistant to peptic digestion at acidic pH, thus preserving the properties critical for oral infection. The infection process is also influenced by gp90, a metacyclic stage-specific molecule that negatively regulates the invasion process. T. cruzi strains expressing high gp90 levels invade cells poorly in vitro. However, their infectivity by oral route varies considerably due to varying susceptibilities of different gp90 isoforms to peptic digestion. Parasites expressing pepsin-susceptible gp90 become highly invasive against target cells upon contact with gastric juice. Such is the case of a T. cruzi isolate from an acute case of orally acquired Chagas' disease; the gp90 from this strain is extensively degraded upon short period of parasite permanence in the gastric milieu. If such an exacerbation of infectivity occurs in humans, it may be responsible for the severity of Chagas' disease reported in outbreaks of oral infection.Universidade Federal de São Paulo (UNIFESP) Departamento de Microbiologia, Imunologia e ParasitologiaUNIFESP, Depto. de Microbiologia, Imunologia e ParasitologiaSciEL
A symbolic semantics for a clculus for service-oriented computing
We introduce a symbolic characterisation of the operational semantics of COWS, a formal language for specifying and combining service-oriented applications, while modelling their dynamic behaviour. This alternative semantics avoids infinite representations of COWS terms due to the value-passing nature of communication in COWS and is more amenable for automatic manipulation by analytical tools, such as e.g. equivalence and model checkers. We illustrate our approach through a ‘translation service’ scenario
Timed Runtime Monitoring for Multiparty Conversations
We propose a dynamic verification framework for protocols in real-time distributed systems. The framework is based on Scribble, a tool-chain for design and verification of choreographies based on multiparty session types, developed with our industrial partners. Drawing from recent work on multiparty session types for real-time interactions, we extend Scribble with clocks, resets, and clock predicates constraining the times in which interactions should occur. We present a timed API for Python to program distributed implementations of Scribble specifications. A dynamic verification framework ensures the safe execution of applications written with our timed API: we have implemented dedicated runtime monitors that check that each interaction occurs at a correct timing with respect to the corresponding Scribble specification. The performance of our implementation and its practicability are analysed via benchmarking
Characteristic Bisimulation for Higher-Order Session Processes
Characterising contextual equivalence is a long-standing issue for higher-order (process) languages. In the setting of a higher-order pi-calculus with sessions, we develop characteristic bisimilarity, a typed bisimilarity which fully characterises contextual equivalence. To our knowledge, ours is the first characterisation of its kind. Using simple values inhabiting (session) types, our approach distinguishes from untyped methods for characterising contextual equivalence in higher-order processes: we show that observing as inputs only a precise finite set of higher-order values suffices to reason about higher-order session processes. We demonstrate how characteristic bisimilarity can be used to justify optimisations in session protocols with mobile code communication
Lightweight session programming in scala
Designing, developing and maintaining concurrent applications is an error-prone and time-consuming task; most difficulties arise because compilers are usually unable to check whether the inputs/outputs performed by a program at runtime will adhere to a given protocol specification. To address this problem, we propose lightweight session programming in Scala: we leverage the native features of the Scala type system and standard library, to introduce (1) a representation of session types as Scala types, and (2) a library, called lchannels, with a convenient API for session-based programming, supporting local and distributed communication. We generalise the idea of Continuation-Passing Style Protocols (CPSPs), studying their formal relationship with session types. We illustrate how session programming can be carried over in Scala: how to formalise a communication protocol, and represent it using Scala classes and lchannels, letting the compiler help spotting protocol violations. We attest the practicality of our approach with a complex use case, and evaluate the performance of lchannels with a series of benchmarks
- …