Reactive Async: expressive deterministic concurrency

Haller, Philipp; Geries, Simon; Eichberg, Michael; Salvaneschi, Guido

doi:10.1145/2998392.2998396

Cited by 8 publications

(6 citation statements)

References 28 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…1 The plugin can be enabled when building Scala projects using the sbt or Maven build tools. The immutability analysis is implemented using Reactive Async [4] which extends LVars [6], lattice-based variables, with cyclic dependency resolution. For each template definition we maintain a "cell" that keeps track of the immutability property of the template.…”

Section: Methodsmentioning

confidence: 99%

Quantifying and Explaining Immutability in Scala

Haller¹,

Axelsson²

2017

Electron. Proc. Theor. Comput. Sci.

Self Cite

View full text Add to dashboard Cite

Functional programming typically emphasizes programming with first-class functions and immutable data. Immutable data types enable fault tolerance in distributed systems, and ensure process isolation in message-passing concurrency, among other applications. However, beyond the distinction between reassignable and non-reassignable fields, Scala's type system does not have a built-in notion of immutability for type definitions. As a result, immutability is "by-convention" in Scala, and statistics about the use of immutability in real-world Scala code are non-existent. This paper reports on the results of an empirical study on the use of immutability in several medium-to-large Scala open-source code bases, including Scala's standard library and the Akka actor framework. The study investigates both shallow and deep immutability, two widely-used forms of immutability in Scala. Perhaps most interestingly, for type definitions determined to be mutable, explanations are provided for why neither the shallow nor the deep immutability property holds; in turn, these explanations are aggregated into statistics in order to determine the most common reasons for why type definitions are mutable rather than immutable.

show abstract

Section: Methodsmentioning

confidence: 99%

Quantifying and Explaining Immutability in Scala

Haller¹,

Axelsson²

2017

Electron. Proc. Theor. Comput. Sci.

Self Cite

View full text Add to dashboard Cite

show abstract

“…Haller et al [36] concurrently execute tasks based on lattices and apply this to static analysis. Their framework requires dependencies to be managed fully by the client while OPAL manages them automatically based on declarative specifications.…”

Section: Imperative Approaches and Parallelizationmentioning

confidence: 99%

Modular collaborative program analysis in OPAL

Helm

Kübler

Reif

et al. 2020

Proceedings of the 28th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Softw

Self Cite

View full text Add to dashboard Cite

Current approaches combining multiple static analyses deriving different, independent properties focus either on modularity or performance. Whereas declarative approaches facilitate modularity and automated, analysis-independent optimizations, imperative approaches foster manual, analysis-specific optimizations. In this paper, we present a novel approach to static analyses that leverages the modularity of blackboard systems and combines declarative and imperative techniques. Our approach allows exchangeability, and pluggable extension of analyses in order to improve sound(i)ness, precision, and scalability and explicitly enables the combination of otherwise incompatible analyses. With our approach integrated in the OPAL framework, we were able to implement various dissimilar analyses, including a points-to analysis that outperforms an equivalent analysis from Doop, the state-of-the-art points-to analysis framework. CCS CONCEPTS • Software and its engineering → Abstraction, modeling and modularity; Automated static analysis; • Theory of computation → Program analysis; Parallel computing models.

show abstract

“…Recently Haller et al [29] have developed Reactive Async, a new event-based asynchronous concurrent programming model that improves on LVars. This approach extends futures and promises 8 with lattice-based operations in order to support destructive updates (refinement of results) in a deterministic concurrent setting.…”

Section: Related Workmentioning

confidence: 99%

Deterministic Concurrency: A Clock-Synchronised Shared Memory Approach

Aguado

Mendler

Pouzet

et al. 2018

Lecture Notes in Computer Science

View full text Add to dashboard Cite

Synchronous Programming (SP) is a universal computational principle that provides deterministic concurrency. The same input sequence with the same timing always results in the same externally observable output sequence, even if the internal behaviour generates uncertainty in the scheduling of concurrent memory accesses. Consequently, SP languages have always been strongly founded on mathematical semantics that support formal program analysis. So far, however, communication has been constrained to a set of primitive clock-synchronised shared memory (csm) data types, such as data-flow registers, streams and signals with restricted read and write accesses that limit modularity and behavioural abstractions. This paper proposes an extension to the SP theory which retains the advantages of deterministic concurrency, but allows communication to occur at higher levels of abstraction than currently supported by SP data types. Our approach is as follows. To avoid data races, each csm type publishes a policy interface for specifying the admissibility and precedence of its access methods. Each instance of the csm type has to be policy-coherent, meaning it must behave deterministically under its own policy-a natural requirement if the goal is to build deterministic systems that use these types. In a policy-constructive system, all access methods can be scheduled in a policy-conformant way for all the types without deadlocking. In this paper, we show that a policy-constructive program exhibits deterministic concurrency in the sense that all policyconformant interleavings produce the same input-output behaviour. Policies are conservative and support the csm types existing in current SP languages. Technically, we introduce a kernel SP language that uses arbitrary policy-driven csm types. A big-step fixed-point semantics for this language is developed for which we prove determinism and termination of constructive programs.

show abstract

Reactive Async: expressive deterministic concurrency

Cited by 8 publications

References 28 publications

Quantifying and Explaining Immutability in Scala

Quantifying and Explaining Immutability in Scala

Modular collaborative program analysis in OPAL

Deterministic Concurrency: A Clock-Synchronised Shared Memory Approach

Contact Info

Product

Resources

About