11 research outputs found
Concurrent Typestate-Oriented Programming in Java
We describe a generative approach that enables concurrent typestate-oriented
programming in Java and other mainstream languages. The approach allows
programmers to implement objects exposing a state-sensitive interface using a
high-level synchronization abstraction that synchronizes methods with the
states of the receiver object in which those methods have an effect. An
external tool takes care of generating all the boilerplate code that implements
the synchronization logic. Behavioral types are used to specify object
protocols. The tool integrates protocol conformance verification with the
synchronization logic so that protocol violations are promptly detected at
runtime.Comment: In Proceedings PLACES 2019, arXiv:1904.0039
Composing Interfering Abstract Protocols
The undisciplined use of shared mutable state can be a source of program errors when aliases unsafely interfere with each other.
While protocol-based techniques to reason about interference abound, they do not address two practical concerns: the decidability of protocol composition and its integration with protocol abstraction.
We show that our composition procedure is decidable and that it ensures safe interference even when composing abstract protocols.
To evaluate the expressiveness of our protocol framework for safe shared memory interference, we show how this same protocol framework can be used to model safe, typeful message-passing concurrency idioms
A Type Checking Algorithm for Concurrent Object Protocols
Concurrent objects can be accessed and possibly modified concurrently by several running processes. It is notoriously difficult to make sure that such objects are consistent with – and are used according to – their intended protocol. In this paper we detail a type checking algorithm for concurrent objects protocols that provides automated support for this verification task. We model concurrent objects in the Objective Join Calculus and specify protocols using terms of a Commutative Kleene Algebra. The presented results are an essential first step towards the application of this static analysis technique to real-world programs
Papaya: Global Typestate Analysis of Aliased Objects
Typestates are state machines used in object-oriented programming to specify and verify correct order of method calls on an object. To avoid inconsistent object states, typestates enforce linear typing, which eliminates - or at best limits - aliasing. However, aliasing is an important feature in programming, and the state-of-the-art on typestates is too restrictive if we want typestates to be adopted in real-world software systems.
In this paper, we present a type system for an object-oriented language with typestate annotations, which allows for unrestricted aliasing, and as opposed to previous approaches it does not require linearity constraints. The typestate analysis is global and tracks objects throughout the entire program graph, which ensures that well-typed programs conform and complete the declared protocols. We implement our framework in the Scala programming language and illustrate our approach using a running example that shows the interplay between typestates and aliases
Deadlock-Free Typestate-Oriented Programming
Context. TypeState-Oriented Programming (TSOP) is a paradigm intended to help
developers in the implementation and use of mutable objects whose public
interface depends on their private state. Under this paradigm, well-typed
programs are guaranteed to conform with the protocol of the objects they use.
Inquiry. Previous works have investigated TSOP for both sequential and
concurrent objects. However, an important difference between the two settings
still remains. In a sequential setting, a well-typed program either progresses
indefinitely or terminates eventually. In a concurrent setting, protocol
conformance is no longer enough to avoid deadlocks, a situation in which the
execution of the program halts because two or more objects are involved in
mutual dependencies that prevent any further progress.
Approach. In this work, we put forward a refinement of TSOP for concurrent
objects guaranteeing that well-typed programs not only conform with the
protocol of the objects they use, but are also deadlock free. The key
ingredients of the type system are behavioral types, used to specify and
enforce object protocols, and dependency relations, used to represent abstract
descriptions of the dependencies between objects and detect circularities that
might cause deadlocks.
Knowledge. The proposed approach stands out for two features. First, the
approach is fully compositional and therefore scalable: the objects of a large
program can be type checked in isolation; deadlock freedom of an object
composition solely depends on the types of the objects being composed; any
modification/refactoring of an object that does not affect its public interface
does not affect other objects either. Second, we provide the first deadlock
analysis technique for join patterns, a high-level concurrency abstraction with
which programmers can express complex synchronizations in a succinct and
declarative form.
Grounding. We detail the proposed typing discipline for a core programming
language blending concurrent objects, asynchronous message passing and join
patterns. We prove that the type system is sound and give non-trivial examples
of programs that can be successfully analyzed. A Haskell implementation of the
type system that demonstrates the feasibility of the approach is publicly
available.
Importance. The static analysis technique described in this work can be used
to certify programs written in a core language for concurrent TSOP with proven
correctness guarantees. This is an essential first step towards the integration
and application of the technique in a real-world developer toolchain, making
programming of such systems more productive and less frustrating
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
Special Delivery: Programming with Mailbox Types (Extended Version)
The asynchronous and unidirectional communication model supported by
mailboxes is a key reason for the success of actor languages like Erlang and
Elixir for implementing reliable and scalable distributed systems. While many
actors may send messages to some actor, only the actor may (selectively)
receive from its mailbox. Although actors eliminate many of the issues stemming
from shared memory concurrency, they remain vulnerable to communication errors
such as protocol violations and deadlocks.
Mailbox types are a novel behavioural type system for mailboxes first
introduced for a process calculus by de'Liguoro and Padovani in 2018, which
capture the contents of a mailbox as a commutative regular expression. Due to
aliasing and nested evaluation contexts, moving from a process calculus to a
programming language is challenging.
This paper presents Pat, the first programming language design incorporating
mailbox types, and describes an algorithmic type system. We make essential use
of quasi-linear typing to tame some of the complexity introduced by aliasing.
Our algorithmic type system is necessarily co-contextual, achieved through a
novel use of backwards bidirectional typing, and we prove it sound and complete
with respect to our declarative type system. We implement a prototype type
checker, and use it to demonstrate the expressiveness of Pat on a factory
automation case study and a series of examples from the Savina actor benchmark
suite.Comment: Extended version of paper accepted to ICFP'2
The chemical approach to typestate-oriented programming
We introduce a novel approach to typestate-oriented programming based on the chemical metaphor: state and operations on objects are molecules of messages, and state transformations are chemical reactions. This approach allows us to investigate typestate in an inherently concurrent setting, whereby objects can be accessed and modified concurrently by several processes, each potentially changing only part of their state. We introduce a simple behavioral type theory to express in a uniform way both the private and the public interfaces of objects; describe and enforce structured object protocols consisting of possibilities, prohibitions, and obligations; and control object sharing