Exploring the Reactive Extensions in JavaScript

Asynchronous programming is a ubiquitous systems programming idiom for managing concurrent interactions with the environment. In this style, instead of waiting for time-consuming operations to complete, the programmer makes a non-blocking call to the operation and posts a callback task to a task buffer that is executed later when the time-consuming operation completes. A cooperative scheduler mediates the interaction by picking and executing callback tasks from the task buffer to completion (and these callbacks can post further callbacks to be executed later). Writing correct asynchronous programs is hard because the use of callbacks, while efficient, obscures program control flow. We provide a formal model underlying asynchronous programs and study verification problems for this model. We show that the safety verification problem for finite-data asynchronous programs is expspace-complete. We show that liveness verification for finite-data asynchronous programs is decidable and polynomial-time equivalent to Petri net reachability. Decidability is not obvious, since even if the data is finite-state, asynchronous programs constitute infinite-state transition systems: both the program stack for an executing task and the task buffer of pending calls to tasks can be potentially unbounded. Our main technical constructions are polynomial-time, semantics-preserving reductions from asynchronous programs to Petri nets and back. The first reduction allows the use of algorithmic techniques on Petri nets for the verification of asynchronous programs, and the second allows lower bounds on Petri nets to apply also to asynchronous programs. We also study several extensions to the basic models of asynchronous programs that are inspired by additional capabilities provided by implementations of asynchronous libraries and classify the decidability and undecidability of verification questions on these extensions.

The model of asynchronous programming arises in many contexts, from low-level systems software to high-level web programming. We take a language-theoretic perspective and show general decidability and undecidability results for asynchronous programs that capture all known results as well as show decidability of new and important classes. As a main consequence, we show decidability of safety, termination and boundedness verification for higher-order asynchronous programs -- such as OCaml programs using Lwt -- and undecidability of liveness verification already for order-2 asynchronous programs. We show that under mild assumptions, surprisingly, safety and termination verification of asynchronous programs with handlers from a language class are decidable iff emptiness is decidable for the underlying language class. Moreover, we show that configuration reachability and liveness (fair termination) verification are equivalent, and decidability of these problems implies decidability of the well-known equal-letters problem on languages. Our results close the decidability frontier for asynchronous programs.

Asynchronous programming is a standard approach for designing responsive applications. Modern languages such as C# provide async/await primitives for the disciplined use of asynchrony. In spite of this, programs can deadlock because of incorrect use of blocking operations along with non-blocking (asynchronous) operations. While developers are aware of this problem, there is no automated technique to detect deadlocks in asynchronous programs.

Asynchronous programming is a standard approach for designing responsive applications. Modern languages such as C# provide async/await primitives for the disciplined use of asynchrony. In spite of this, programs can deadlock because of incorrect use of blocking operations along with non-blocking (asynchronous) operations. While developers are aware of this problem, there is no automated technique to detect deadlocks in asynchronous programs. We present a novel representation of control flow and scheduling of asynchronous programs, called continuation scheduling graph and formulate necessary conditions for a deadlock to occur in a program. We design static analyses to construct continuation scheduling graphs of asynchronous C# programs and to identify deadlocks in them. We have implemented the static analyses in a tool called DeadWait. Using DeadWait, we found 43 previously unknown deadlocks in 11 asynchronous C# libraries. We reported the deadlocks to the library developers. They have confirmed and fixed 40 of them.

Developing interactive and distributive softwares is a complicated task for many reasons including the nature of this technique of programming; asynchronous programming. In this style of programming, there is no synchronization between running processes concerning message-posting communications. Therefore the presence of nonterminating executions for asynchronous programs, as a result of simple programming errors, is common.

JavaScript programmers make extensive use of event-driven programming to help build responsive web applications. However, standard approaches to sequencing events are messy, and often lead to code that is difficult to understand and maintain. We have found that arrows, a generalization of monads, are an elegant solution to this problem. Arrows allow us to easily write asynchronous programs in small, modular units of code, and flexibly compose them in many different ways, while nicely abstracting the details of asynchronous program composition. In this paper, we present Arrowlets, a new JavaScript library that offers arrows to the everyday JavaScript programmer. We show how to use Arrowlets to construct a variety of state machines, including state machines that branch and loop. We also demonstrate how Arrowlets separate computation from composition with examples such as a drag-and-drop handler and a bubblesort animation.

Recently, there has been increasing interest in learning semantic parsers with indirect supervision, but existing work focuses almost exclusively on question answering. Separately, there have been active pursuits in leveraging databases for distant supervision in information extraction, yet such methods are often limited to binary relations and none can handle nested events. In this paper, we generalize distant supervision to complex knowledge extraction, by proposing the first approach to learn a semantic parser for extracting nested event structures without annotated examples, using only a database of such complex events and unannotated text. The key idea is to model the annotations as latent variables, and incorporate a prior that favors semantic parses containing known events. Experiments on the GENIA event extraction dataset show that our approach can learn from and extract complex biological pathway events. Moreover, when supplied with just five example words per event type, it becomes competitive even among supervised systems, outperforming 19 out of 24 teams that participated in the original shared task.

Complex event processing (CEP) and Reactive Languages (RLs) are examples of solutions for the so-called reactive applications. Such applications are designed to detect and react to changes or event occurrences as they happen in a timely fashion. Both CEP and RLs have been developed by different communities, yet some researchers agree that they share certain aspects and could perhaps be integrated. With that in mind, we developed a JavaScript library called CEP.js that leverages the well-known Reactive Extensions for JavaScript (RxJS) to offer not only general-purpose stream operations but also CEP ones. The fact of being a JavaScript library allows CEP.js to be used in Web applications and easily embedded into mobile applications. Therefore, it opens many possibilities for CEP in mobile client applications. It also raises the concern of energy efficiency since CEP applications commonly have to deal with a significant number of events, and its continuous operations on data flows may incur significant processing. Even though CEP.js has been designed after RxJS, it was conceived in a loosely coupled way that the underlying reactive library should be easily replaced if needed. In addition to presenting the CEP.js library, in this paper, we investigate if there is any significant change in performance by running an experiment where the replacement of the reactive library used in CEP.js is the main factor analyzed. The experiment was executed in different Android devices, focusing specifically on energy consumption, an essential non-functional requirement in the smartphone realm.

Event-driven Process Chain (EPC) is a known business process modeling language which is primarily renowned for efficient modeling of business requirements. It is a semi-formal modeling language which is commonly verified though various formal mechanism for simple atomic events. However, the complexity of business requirements cannot be modeled through EPC atomic events alone especially in case of real time systems. Therefore, the complex events patterns like Event Time, Event location, Event Cardinality, Event Sequence, Event Exclusion, Event Trend and Data dependency are introduced in EPC from the novel area of complex event processing. However, to the best of our knowledge, there is no mechanism available in EPC to model and verify such complex events. Therefore, in this paper, we investigate the verification possibilities of both (atomic and complex) events in the context of Timed-Automata (TA) and Time Petri Nets (TPN). Particularly, we try to map the semantics of simple and complex events with the corresponding concepts of TA and TPN. It is analyzed that the simple EPC events can be formalized through TA and TPN but limited support is available for complex events. The restaurant process case study has been used for further investigation of complex events. It has been concluded that TA formalism is more suitable than TPN for the verification of complex events in EPC.

Autonomous machines such as a planetary explorer must learn from the real universe, which can be seen as a single event of infinite complexity or as an infinite set of trivial events. Current inductive learning systems generalize from a finite set of events provided by a human teacher or a software environment. Even a constrained universe is difficult to represent as a finite set of events comprising various types of useful information. Cues used by humans to perform this representation task include temporal or spatial relationships among environmental data. We discuss a method for identifying meaningful complex events in the universe of an autonomous learning robot. When no temporal concept is known to link two descriptors, temporal proximity of events is used to pair simple descriptor events into complex events for inductive learning. When a temporal concept is known to link two descriptors, that concept is used to guide the pairing of descriptor events. We discuss the efficiency improvements which arise from using temporal concepts in this manner. The method is embedded in GPAL 1.3, a general purpose autonomous learner that uses a knowledge-based learning and control strategy which models the scientific method.

We present a general framework for complex event recognition that is well-suited for integrating information that varies widely in detail and granularity. Consider the scenario of an agent in an instrumented space performing a complex task while describing what he is doing in a natural manner. The system takes in a variety of information, including objects and gestures recognized by RGB-D and descriptions of events extracted from recognized and parsed speech. The system outputs a complete reconstruction of the agent's plan, explaining actions in terms of more complex activities and filling in unobserved but necessary events. We show how to use Markov Logic (a probabilistic extension of first-order logic) to create a model in which observations can be partial, noisy, and refer to future or temporally ambiguous events; complex events are composed from simpler events in a manner that exposes their structure for inference and learning; and uncertainty is handled in a sound probabilistic manner. We demonstrate the effectiveness of the approach for tracking kitchen activities in the presence of noisy and incomplete observations.

In the context of computer vision, most of the traditional action recognition techniques assign a single label to a video after analyzing the whole video. We believe that under- standing of the visual world is not limited to recognizing a specific action class or individual object instances, but also extends to how those objects interact in the scene, which im- plies recognizing events happening in the scene. In this paper we present an approach for identifying complex events in videos, starting from detection of objects and simple events using a state-of-the-art object detector (YOLO). We provide a logic based representation of events by using a realization of the Event calculus that allows us to define complex events in terms of logical rules. Axioms of the calculus are encoded in a logic program under Answer Set semantics in order to reason and formulate queries over the extracted events. The applicability of the framework is demonstrated over the scenario of recognizing different kinds of kick events in soccer videos.

Composite event monitoring in XML repositories using generic rule framework for providing reactive e-services

The notion of "events" is extremely important in characterizing the contents of video. An event is typically triggered by some kind of change of state captured in the video, such as when an object starts moving. The ability to reason with events is a critical step toward video understanding. This article describes the findings of a recent workshop series that has produced an ontology framework for representing video events-called Video Event Representation Language (VERL) -and a companion annotation framework, called Video Event Markup Language (VEML). One of the key concepts in this work is the modeling of events as composable, whereby complex events are constructed from simpler events by operations such as sequencing, iteration, and alternation. The article presents an extensible event and object ontology expressed in VERL and discusses a detailed example of applying VERL and VEML to the description of a "tailgating" event in surveillance video.

Turbidity behavior in streams is a complex and dynamic function of both source material supply and event‐driven transport. While the primary controls on turbidity behavior across time and space are still not fully understood, recent increases in the availability of high temporal resolution, colocated stream turbidity, and discharge data provide an opportunity for more detailed analysis. Here we examine methods to quantitatively characterize event responses by modeling the shape of turbidity‐discharge hysteresis loops. A total of 1559 events from 20 gages in the Mid‐Atlantic region of the U.S. were modeled using both previously reported models and new models combining elements of existing models. The results suggest that a more general power law‐based model, utilizing both a discharge rate of change term and a “supply” term, allows characterization of a wide range of simple and complex events. Additionally, this study explores a decorrelation approach to address the strong correlation frequently observed between the power law model coefficient ( ) and exponent ( ), with the goal of exposing the underlying behavior of each parameter individually. An examination of seasonal parameter behavior suggests that this approach may facilitate greater physically based interpretation of the power law coefficient. The power law parameter decorrelation strategy and the loop models examined here provide a step toward the larger goal of understanding the physical controls on turbidity‐discharge hysteretic behavior.