Towards Composable Concurrency Abstractions

Programming methodology, 2003

While the conceptual development of programming paradigms from code-routines operating on a single, linear memory all the way up to hierarchically structured metaphoric worlds of objects supported by under-the-hood runtime mechanisms like garbage collection is truly impressive, one essential topic has largely been neglected: concurrency. Programmers writing concurrent programs still need to rely on low-level locking models or on cumbersome workarounds. This is particularly relevant in view of multicore processing hardware available today when concurrency is becoming the norm and real in contrast with just exceptional and simulated. We argue in favor of synthesizing concurrency into object-orientation by introducing a concept of « self-active objects ».

Proceedings of the 4th Workshop on Scala - SCALA '13, 2013

Declarative dataflow values are single assignment variables such that all operations needing their values wait automatically until the values are available. Adding threads and declarative dataflow values to a functional language gives declarative concurrency, a model in which concurrency is deterministic and explicit synchronization is not needed. In our experience, this greatly simplifies the writing of concurrent programs (as explained in several chapters of CTM [20]). We complete this model with lazy execution and message-passing concurrency. Both extensions are tightly integrated with the declarative dataflow core. Lazy execution is provided by extending declarative dataflow with a by-need synchronization operation. Message passing is provided by adding streams equipped with a send operation, where a stream is a list with an unbound single-assignment variable. This paper presents the Ozma language, a conservative extension of Scala that supports all these concepts. We have made a complete implementation of Ozma by combining the implementations of Scala and Oz. Evaluation shows that this implementation supports the full semantics of Scala with concurrent programs based on the new concurrency model. In particular, within the functional subset of Scala the new concurrency model fully supports deterministic concurrency.

Lecture Notes in Computer Science, 2003

Logic variables pioneered by (concurrent) logic and concurrent constraint programming are powerful mechanisms for automatically synchronizing concurrent computations. They support a declarative model of concurrency that avoids explicitly suspending and resuming computations. This paper presents Flow Java which conservatively extends Java with single assignment variables and futures as variants of logic variables. The extension is conservative with respect to objectorientation, types, parameter passing, and concurrency in Java. Futures support secure concurrent abstractions and are essential for seamless integration of single assignment variables into Java. We show how Flow Java supports the construction of simple and concise concurrent programming abstractions. We present how to moderately extend compilation and the runtime architecture of an existing Java implementation for Flow Java. Evaluation using standard Java benchmarks shows that in most cases the overhead is between 10% and 40%. For some pathological cases the runtime increases by up to 75%.

2008 13th Asia-Pacific Computer Systems Architecture Conference, 2008

This is a discussion paper on a very important topic that is about to become mainstream. It deals with the issues of software engineering in concurrent systems. It introduces this topic and illustrates the arguments for a change of perspective. It underlines these arguments with two examples, an asynchronous stream-based programming model and an asynchronous thread-based virtual machine model. Both support concurrency on very different abstractions but both capture similar support for concurrency engineering.

Formal Techniques for Distributed Objects, Components, and Systems, 2017

This paper concerns formal models for the analysis of communication-centric software systems that feature declarative and reactive behaviors. We focus on session-based concurrency, the interaction model induced by session types, which uses (variants of) the π-calculus as specification languages. While well-established, such process models are not expressive enough to specify declarative and reactive behaviors common in emerging communication-centric software systems. Here we propose the synchronous reactive programming paradigm as a uniform foundation for session-based concurrency. We present correct encodings of session-based calculi into ReactiveML, a synchronous reactive programming language. Our encodings bridge the gap between process specifications and concurrent programs in which session-based concurrency seamlessly coexists with declarative, reactive, timed, and contextual behaviors.

Aldwych is proposed as the foundation of a general purpose language for parallel applications. It has aspects variously of concurrent, functional, logic and object-oriented languages, and may also interface with existing systems like a coordination language, yet it forms an integrated whole. It is intended to be applicable both for small-scale parallel programming, and for large-scale open systems Keywords: Concurrency, actors, multi-paradigm languages, coordination, open systems. 1. Introduction The language Linda [Gele 85] was launched as the underdog, competing against sophisticated approaches to parallel programming [Ca & Ge 89], but has triumphed over those approaches it then saw as its competitors, to the point where it is now seen as the generic model for "co-ordination languages" [Ci & Ha 96]. As its authors note [Ge & Ca 92] one of the main reasons for this is that Linda provided a simple "glue" that could be used to combine systems written in languages ...

SAVCBS 2004 Specification and Verification of Component-Based Systems, 2004

We extend traditional techniques for sequential specification and verification to systems involving intrinsically concurrent activities. Our approach uses careful design of component specifications to encapsulate inherent concurrency, and hence isolate clients from associated verification concerns. The approach has three parts:(i) relational specifications to capture the interleaved effects of concurrent threads of execution,(ii) intermediate components to support a client's view of being the only active thread of ...

2012

Abstraction is a crucial tool in specifying and justifying developments of systems. This observation is recognised in many different methods for developing sequential software; it also applies to some approaches to the formal development of concurrent systems although there its use is perhaps less uniform. The rely/guarantee approach to formal design has, for example, been shown to be capable of recording the design of complex concurrent software in a “top down” stepwise process that proceeds from abstract specification to code.

Formal Aspects of Computing, 2009

We present a new concurrency model for the Eiffel programming language. The model is motivated by describing a number of semantic problems with the leading concurrency model for Eiffel, namely SCOOP. Our alternative model aims to preserve the existing behaviour of sequential programs and libraries wherever possible. Comparison with the SCOOP model is made. The concurrency aspects of the alternative model are presented in CSP along with a model of exceptions. The results show that while the new model provides increased parallelism, this comes with the price of increased overhead due to lock management.