# LtU Forum

Published articles for LtU Forum.

This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles.

## Tackling the Awkward Squad for Reactive Programming

DevFeed: [Tackling the Awkward Squad for Reactive Programming](<https://devfeed.tech/articles/tackling-the-awkward-squad-for-reactive-programming-29482.md>)

Original publisher: [Read original article](<http://lambda-the-ultimate.org/node/5603>)

Published: 2020-09-15T17:48:50Z

Content type: article

Language: en

Sources: [Lambda the Ultimate](<https://devfeed.tech/sources/lambda-the-ultimate.md>)

Topics: [reactive](<https://devfeed.tech/topics/reactive.md>), [Programming](<https://devfeed.tech/topics/programming.md>), [IO](<https://devfeed.tech/topics/io.md>), [Scala](<https://devfeed.tech/topics/scala.md>), [JavaScript](<https://devfeed.tech/topics/javascript.md>)

Tags: [effects](<https://devfeed.tech/tags/effects.md>), [implementation](<https://devfeed.tech/tags/implementation.md>), [javascript](<https://devfeed.tech/tags/javascript.md>), [ltu-forum](<https://devfeed.tech/tags/ltu-forum.md>), [programming](<https://devfeed.tech/tags/programming.md>), [reactive](<https://devfeed.tech/tags/reactive.md>), [reactive-programming](<https://devfeed.tech/tags/reactive-programming.md>), [scala](<https://devfeed.tech/tags/scala.md>), [streams](<https://devfeed.tech/tags/streams.md>)

### AI overview

This paper examines how reactive programming is embedded within applications that also use imperative languages such as JavaScript or Scala. It identifies long-running computations, side effects, and coordination between imperative and reactive code as key concerns, then proposes the Actor-Reactor Model, which separates actors and reactors and composes them through data streams. The model is demonstrated in the Stella language.

### Source excerpt

https://2020.ecoop.org/details/ecoop-2020-papers/19/Tackling-the-Awkward-Squad-for-Reactive-Programming-The-Actor-Reactor-Model Sam Van den Vonder, Thierry Renaux, Bjarno Oeyen, Joeri De Koster, Wolfgang De Meuter Reactive programming is a programming paradigm whereby programs are internally represented by a dependency graph, which is used to automatically (re)compute parts of a program whenever its input changes. In practice reactive programming can only be used for some parts of an application: a reactive program is usually embedded in an application that is still written in ordinary imperative languages such as JavaScript or Scala. In this paper we investigate this embedding and we distill "the awkward squad for reactive programming" as 3 concerns that are essential for real-world software development, but that do not fit within reactive programming. They are related to long lasting computations, side-effects, and the coordination between imperative and reactive code. To solve these issues we design a new programming model called the Actor-Reactor Model in which programs are split up in a number of actors and reactors. Actors and reactors enforce a strict separation of imperative and reactive code, and they can be composed via a number of composition operators that make use of data streams. We demonstrate the model via our own implementation in a language called Stella.