English (United Kingdom)

https://curated-unify.zendy.io/wp-json/zendy-region/v1/featured_content/oa?rat=en

https://curated-unify.zendy.io/wp-json/zendy-region/v1/highlighted_journal/

Global: Zendy Plus annual

Presents the access of premium content as premium feature

Premium Content

Presents the keyphrase highlighting as premium feature

Keyphrase Highlighting

Presents the summarisation as premium feature

Summarisation

Insights

Presents the pdf analysis as premium feature

PDF Analysis

Presents the zaia usage as premium feature

ZAIA

Global: Zendy Plus monthly

Global: Zendy Tools annual

Global: Zendy Tools monthly

Global: Zendy Free Plan

The current demands for seamless connections with the surrounding environmentmake software more reactive. For example, such demands are evident in systemsconsisting of the Internet of Things. Such systems include a set of reactivevalues that are periodically updated in response to external or internal eventsto form a dataflow in the sense that such updates are propagated to otherreactive values. Two effective approaches for realizing such reactive valueshave been proposed: the event mechanisms in event-based programming and thesignals in functional-reactive programming. These two approaches are nowbecoming mixed in several languages such as Flapjax and REScala, which makesthese languages notably expressive for modularizing the implementation ofreactive software. For example, REScala provides a rich API that consists offunctions converting events to signals and vice versa.  In this paper, we explore another, simpler approach in the design space ofreactive programming languages: the event mechanism is harmonized with signals,resulting in a simplified programming interface that is mostly based onsignals. Based on this approach, we realize SignalJ, a simple extension of Javawith events and signals. Our notable findings are (1) an event can berepresented as an update of a signal and (2) such an effectful signal can berepresented using annotations instead of introducing types and constructors forsignals to further simplify the language.  Another contribution of this paper is the formal model of SignalJ. As bothmechanisms of events and signals may interfere with each other, this mixingsometimes results in surprising behavior. For example, the functional behaviorof signals is affected by the imperative features of events. Thus,understanding the formal model of this mixing is actually important. The corecalculus, Featherweight SignalJ (FSJ), was developed as an extension ofFeatherweight Java, and proofs are provided to ensure the soundness of FSJ.

Harmonizing Signals and Events with a Lightweight Extension to Java