Distributed REScala

Drechsler, Joscha; Salvaneschi, Guido; Mogk, Ragnar; Mezini, Mira

doi:10.1145/2660193.2660240

Cited by 27 publications

(13 citation statements)

References 30 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…The other extreme alternative to our tier-crossing semantics is glitch-freedom in a distributed setting [11,16,18]. In other words, across the distributed reactive program there can never be an observable partial propagation.…”

Section: Total Glitch Freedommentioning

confidence: 99%

“…In the field of distributed reactive programming there are several programming languages or even algorithms that describe systems relevant to our multi-tier implementation of FRP with tiered glitch freedom such as SID-UP [11], DREAM [16] and QPROPd [18].…”

Section: Related Workmentioning

confidence: 99%

“…Several other distributed reactive algorithms were proposed with similar goals. SID-UP [11], a distributed glitch-free propagation algorithm that minimizes messages compared to DREAM and requires a centralized "lock" that makes the distributed program unable to process more than one propagation at a time. QPROP [18], an 6:25 algorithm that provides distributed glitch-free propagation that does not require a central coordinator for locking.…”

Section: Local Glitch Freedommentioning

confidence: 99%

“…Distributed reactive programming languages [11,16,18] have distributed consistency guarantees and allow distributed FRP propagation without observable partial propagations (glitches). ScalaLoci [35] in particular -a general purpose multi-tier extension of Scala which allows programmers to define their own distribution schemesupports tier-crossing primitives with distributed consistency guarantees.…”

Section: Introductionmentioning

confidence: 99%

See 3 more Smart Citations

Gavial: Programming the web with multi-tier FRP

2020

View full text Add to dashboard Cite

Web applications are inherently distributed, and not just because their client and server counterparts run on networked systems. Web applications are written in multiple programming languages and as multiple programs: the server and client programs. In an effort to lower the complexity of the web, multi-tier programming was proposed. In multi-tier programming languages the language and its tooling give support to create web applications as a whole, one program is written in one language.Web applications are also inherently asynchronous. On the server, they constantly process several client requests and in the browser they constantly have to react to input, be it from the user or a server. A technique that can be applied to make such programs easier to understand is functional reactive programming. A functional programming model that models an interactive program as compositions between two primitives, behaviors and events.Developing web applications requires dealing with their distributed nature and the natural asynchronicity of user input and network communication. For facilitating this, different researchers have explored the combination of a multi-tier programming language and functional reactive programming. However, existing proposals take his approach only part of the way. Some parts of the application remain imperative, do not consider network traffic overhead of incremental data, compatibility with common APIs like XMLHttpRequest etc., or they do not consider glitches across network communication (or do but introduce locking or overhead)In this paper, we present Gavial: a design and practical implementation of multi-tier FRP that allows constructing a web application as a functionally reactive program. We propose a novel integration of existing techniques such as solutions to bootstrapping web applications, recursive behaviors for web interfaces, asynchronous FRP and incremental behaviors. As well as novel support for tiered glitch freedom, a compromise between performance and glitch-free evaluation of the distributed FRP program, and a three-tiered system suitable for request-response-style applications as well as user-to-user applications. Gavial automatically runs in request-response (XMLHttpRequest) mode or in websocket mode.After applying a number of old and new ideas to create a practical multi-tier FRP implementation in Gavial, we demonstrate it by building an example and show that it can in fact deal realistically with important practical aspects of building web applications. At the same time, we retain the declarative nature of FRP, where behaviors and events have an intuitive, compositional semantics and a clear dependency structure. ACM CCS 2012Listing 2 Delayed DBehavior object DBehavior { def delayed[A](db: ⇒ DBehavior[A]): Behavior[A] }Returning to CircleRoyale, a type Player represents a player's position, and whether he is alive, attacking or dead. The svg method produces the player's circle and optionally the attacking circle as SVG elements. case class Player(position: Vec2D, attacking: ...

show abstract

Section: Total Glitch Freedommentioning

confidence: 99%

Section: Related Workmentioning

confidence: 99%

Section: Local Glitch Freedommentioning

confidence: 99%

Section: Introductionmentioning

confidence: 99%

See 2 more Smart Citations

Gavial: Programming the web with multi-tier FRP

2020

View full text Add to dashboard Cite

show abstract

“…No state-of-the-art systems succeed in providing all of these criteria. Scala.React [Maier and Odersky 2012] and Distributed REScala [Drechsler et al 2014] ensure thread-safety by using a global lock to prohibit parallelism. łContainers and Aggregates, Mutators and Isolatesž [Prokopec et al 2014] do not address consistency even for single-threaded change propagation, and address thread-safety limited to the scope of individual Signals and Events.…”

Section: Introductionmentioning

confidence: 99%

Thread-safe reactive programming

Drechsler

Mogk

Salvaneschi

et al. 2018

Proc. ACM Program. Lang.

Self Cite

View full text Add to dashboard Cite

The execution of an application written in a reactive language involves transfer of data and control flow between imperative and reactive abstractions at well-defined points. In a multi-threaded environment, multiple such interactions may execute concurrently, potentially causing data races and event ordering ambiguities. Existing RP languages either disable multi-threading or handle it at the cost of reducing expressiveness or weakening consistency. This paper proposes a model for thread-safe reactive programming (RP) that ensures abort-free strict serializability under concurrency while sacrificing neither expressiveness nor consistency. We also propose an architecture for integrating a corresponding scheduler into the RP language runtime, such that thread-safety is provided łout-of-the-boxž to the applications.We show the feasibility of our proposal by providing and evaluating a ready-to-use implementation integrated into the REScala programming language. The scheduling algorithm is formally proven correct. A thorough empirical evaluation shows that reactive applications build on top of it scale with multiple threads, while the scheduler incurs acceptable performance overhead in a single-threaded configuration. The scalability enabled by our scheduler is roughly on-par with that of hand-crafted application-specific locking and better than the scalability enabled by a scheduler using an off-the-shelf software transactional memory library. 1 We chose REScala, because its API is designed to support different backend runtimes.Thread-Safe Reactive Programming 107:3 with that of hand-crafted application-specific locking, and better while also providing stronger guarantees than a scheduler using an off-the-shelf Software Transactional Memory library. ğ2 introduces RP concepts from the user perspective, ğ6 positions our approach with respect to related work, and ğ7 concludes the paper and discusses areas of future work. REACTIVE PROGRAMMING IN RESCALAWe introduce (single-threaded) RP from the developer's perspective by implementing an example application in REScala. Our design is inspired by the dining philosophers [Hoare 1985], with philosophers sharing forks around a table. We later introduce concurrency and discuss its effects through multiple threads concurrently executing updates for different philosophers. For flexibility in later examples and benchmarks, the table's SIZE (number of philosophers and forks) is parametric. The User PerspectiveWe introduce Events, Signals, conversions between them and their imperative interactions.Signals. Philosophers are modelled as Vars of type Phil, initially in state Thinking. 1 cases Phil = { Thinking, Eating } 2 val phils = for (j <− 1 until SIZE) yield Var[Phil](Thinking)A REScala Var is a kind of mutable variable. Like ordinary variables, the value of a Var can be read (through now, e.g., phils(1).now reads the current value of the philosopher with index 1) and overwritten (through set(...), e.g., phils(1).set(Eating)). Unlike ordinary variables, changes of Vars are autom...

show abstract

Issues on Performance of Reactive Programming in the Java Ecosystem with Persistent Data Sources

Wyciślik

Ogorek

2019

Advances in Intelligent Systems and Computing

View full text Add to dashboard Cite

Distributed REScala

Cited by 27 publications

References 30 publications

Gavial: Programming the web with multi-tier FRP

Gavial: Programming the web with multi-tier FRP

Thread-safe reactive programming

Issues on Performance of Reactive Programming in the Java Ecosystem with Persistent Data Sources

Contact Info

Product

Resources

About