REScala

Salvaneschi, Guido; Hintz, Gerold; Mezini, Mira

doi:10.1145/2577080.2577083

Cited by 84 publications

(31 citation statements)

References 32 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…The remote communication mechanisms are not hardwired into our implementation and can be extended by implementing the interfaces for (i) message passing over different underlying network protocols (communicators), (ii) different data serialization schemes (serializers) and (iii) different transmission semantics (transmitters), e.g., pull-based remote procedure calls and push-based event streams. We implemented support for different network protocols (e.g., TCP and WebSocket), serializers (e.g., using μPickle [27] or circe [5] for serialization to JSON) and reactive systems (e.g., REScala [50] and Rx [32]). Developers can plug in such implementations as needed for configuring remote communication.…”

Section: Scalaloci In Nucementioning

confidence: 99%

Implementing a Language for Distributed Systems: Choices and Experiences with Type Level and Macro Programming in Scala

Weisenburger

Salvaneschi

2020

Programming

Self Cite

View full text Add to dashboard Cite

Multitier programming languages reduce the complexity of developing distributed software by developing the distributed system within a single coherent code base. In multitier languages, the compiler or the runtime takes care of separating the code into the components of the distributed system. This approach enables abstraction over low level implementation details such as data representation, serialization and network protocols. The ScalaLoci programming language allows developers to declare the components of the system and their architectural relation at the type level, enabling static reasoning about distribution and remote communication and guaranteeing static type safety for data transfer across components. As the compiler automatically generates the communication boilerplate among components, data transfer among components can be modeled declaratively, by specifying the data flows in the reactive programming style.In this paper, we report on the ScalaLoci implementation and on our experience with embedding ScalaLoci's language features into Scala as a host language. We show how a combination of Scala's advanced type level programming and of Scala's macro system enable enriching the language with new abstractions for distributed systems. We describe the challenges we encountered for the implementation and report on the solutions we developed. Finally, we outline suggestions for improving the Scala macro system to better support embedding domain-specific abstractions. ACM CCS 2012The design of ScalaLoci unfolds around three major ideas. First, the distributed topology (i.e., separate locations that execute code) is explicit and specified by the programmer, who assigns code to each system component. Second, remote communication within the distributed system (i.e., with performance and failure characteristics different from local communication) is explicit and supports event-based interaction between components. Third, ScalaLoci abstractions are embedded as domain-specific features into an existing general purpose language. We lay out the design space for our language implementation and derive concrete design requirements.Explicit Specification of Distribution and Topology Some languages for distributed systems abstract over the topology, i.e., code is agnostic to the system's components and their connections. Such approach is often chosen for highly specialized programming models, e.g., streaming systems [16,62], intentionally hiding distribution. On the other end lie approaches where developers specify the topology. Distribution unavoidably becomes apparent when implementing different components, e.g., in actor systems [1]. While actor systems encapsulate components into actors, topological information is not encoded at the language level but managed explicitly by the developer.Clearly, a multitier programming model for developing generic distributed systems -similar to what the actor model offers -cannot abstract over distribution completely. To decide on the component that executes a specific part of the cod...

show abstract

Section: Scalaloci In Nucementioning

confidence: 99%

Implementing a Language for Distributed Systems: Choices and Experiences with Type Level and Macro Programming in Scala

Weisenburger

Salvaneschi

2020

Programming

Self Cite

View full text Add to dashboard Cite

show abstract

“…In FRP implementations, like REScala [12], signals propagate through their dependencies. That means that when a value changes, only relevant parts of the data flow are recalculated.…”

Section: Related Workmentioning

confidence: 99%

PixieDust

Veen

Harkes

Visser

2018

Companion of the the Web Conference 2018 on the Web Conference 2018 - WWW '18

View full text Add to dashboard Cite

Modern web applications are interactive. Reactive programming languages and libraries are the state-of-the-art approach for declaratively specifying these interactive applications. However, programs written with these approaches contain error-prone boilerplate code for efficiency reasons.In this paper we present PixieDust, a declarative user-interface language for browser-based applications. PixieDust uses static dependency analysis to incrementally update a browser-DOM at runtime, without boilerplate code. We demonstrate that applications in PixieDust contain less boilerplate code than state-of-the-art approaches, while achieving on-par performance.

show abstract

“…For example, using the braces operator on the method slot updateA in Fig. 19 (b) cannot select involved events inside b and c. Since RDJ is a Java-based language, where the arguments are evaluated with pass-by-value strategy, a special class [18], [30] or a first-class method slot might be necessary to wrap the expressions passed to updateA. The usage of the braces operator is not declarative.…”

Section: The Limitations Of Rdjmentioning

confidence: 99%

“…We have shown typical translation examples of signals, but it might be interesting to check if it is possible to translate complex use cases such as the examples given in the REScala paper [30]. REScala is a hybrid event system that supports both events and signals, and provides conversion API as primitives for complex usage of signals.…”

Section: Translation Examplesmentioning

confidence: 99%

“…Although the OO community notices the convenience of using signals, OO languages have not been directly integrated with signals. Signals are brought into existing event systems, and existing GUI libraries are wrapped in FRP style [18], [22], [30]. Although events have been used with objects for a long time and well integrated into OO languages, propagating values by events is not implicit enough as propagating by signals.…”

Section: Introductionmentioning

confidence: 99%

See 1 more Smart Citation

Expanding Event Systems to Support Signals by Enabling the Automation of Handler Bindings

Zhuang

Chiba

2016

Journal of Information Processing

View full text Add to dashboard Cite

Abstract:In event-driven programming we can react to an event by binding methods to it as handlers, but such a handler binding in current event systems is explicit and requires explicit reason about the graph of event propagation even for straightforward cases. On the other hand, the handler binding in reactive programming is implicit and constructed through signals. Recent approaches to support either event-driven programming or reactive programming show the need of using both the two styles in a program. We propose an extension to expand event systems to support reactive programming by enabling the automation of handler bindings. With such an extension programmers can use events to cover both the implicit style in reactive programming and the explicit style in event-driven programming. We first describe the essentials of reactive programming, signals and signal assignments, in terms of events, handlers, and bindings, then point out the lack of automation in existing event systems. Unlike most research activities we expand event systems to support signals rather than port signals to event systems. In this paper we also show a prototype implementation and translation examples to evaluate the concept of automation. Furthermore, the comparison with the predicate pointcuts in aspect-oriented programming and the details of the experimental compiler are discussed.

show abstract

REScala

Cited by 84 publications

References 32 publications

Implementing a Language for Distributed Systems: Choices and Experiences with Type Level and Macro Programming in Scala

Implementing a Language for Distributed Systems: Choices and Experiences with Type Level and Macro Programming in Scala

PixieDust

Expanding Event Systems to Support Signals by Enabling the Automation of Handler Bindings

Contact Info

Product

Resources

About