Reactive Async

Reactive Async is a concurrent programming model, which decouples concurrent computations using so-called cells, shared locations which generalize futures as well as deterministic abstractions such as LVars. Compared to previously proposed programming models Reactive Async provides (a) a fallback mechanism for the case where no computation ever computes the value of a given cell, and (b) explicit and optimized handling of cyclic dependencies between cells. In this repository you find a complete implementation of the Reactive Async programming model in and for Scala.

Talk at Scala Days 2016: video, slides

Talk at ACM SIGPLAN Scala Symposium 2016: slides

Paper: Philipp Haller, Simon Geries, Michael Eichberg, and Guido Salvaneschi. Reactive Async: Expressive Deterministic Concurrency. Proc. ACM SIGPLAN Scala Symposium. ACM, 2016. [ACM DL]

Master's thesis: Simon Geries. Reactive Async: Safety and efficiency of new abstractions for reactive, asynchronous programming. KTH, School of Computer Science and Communication (CSC). 2016.

Contributing

Reactive Async is published under the BSD 2-Clause License (see file LICENSE in the project's root directory). Contributions submitted using the normal means to contribute to the project--such as pull requests and patches--indicate the contributors' assent for inclusion of that software in the canonical version under the project's license.

Building

Building Reactive Async requires sbt. Follow these steps:

$ sbt
> project core
> compile

To package the Reactive Async library into a jar file use package instead of compile.

Testing

The test suite (based on ScalaTest) is run as follows:

$ sbt
> project core
> test

Benchmarking

Microbenchmarks

The microbenchmarks (based on ScalaMeter) are run as follows:

$ sbt
> project bench
> test

Note that this consumes a fair amount of memory. Thus, it might be necessary to increase the JVM's maximum heap size before starting sbt.