Reactive Programming Research Articles

Synthesizing structured reactive programs via deterministic tree automata

Existing approaches to the synthesis of controllers in reactive systems typically involve the construction of transition systems such as Mealy automata. In 2011, Madhusudan proposed structured programs over a finite set of Boolean variables as a more succinct formalism to represent the controller. He provided an algorithm to construct such a program from a given ω-regular specification without synthesizing a transition system first. His procedure is based on two-way alternating ω-automata on finite trees that recognize the set of “correct” programs.We present a more elementary and direct approach using only deterministic bottom-up tree automata and extend Madhusudan's results to the wider class of programs with bounded delay, which may read several input symbols before producing an output symbol (or vice versa). In addition, we show a lower bound for the size of these tree automata. Finally, we prove a lower bound for the number of Boolean variables that are required for a structured program to satisfy a given LTL specification, almost matching the known upper bound.

A Novel Reactive Power Compensation Approach Based on Particle Swarm Optimization

The particle swarm optimization (PSO) algorithm as a stochastic search algorithm for solving reactive power optimization problem. The PSO algorithm converges too fast, easy access to local convergence, leading to convergence accuracy is not high, to study the particle swarm algorithm improvements. The establishment of a comprehensive consideration of the practical constraints and reactive power regulation means no power optimization mathematical model, a method using improved particle swarm algorithm for reactive power optimization problem, the algorithm weighting coefficients and inactive particles are two aspects to improve. Meanwhile segmented approach to particle swarm algorithm improved effectively address the shortcomings evolution into local optimum and search accuracy is poor, in order to determine the optimal reactive power optimization program.

Program repair without regret

We present a new and flexible approach to repair reactive programs with respect to a specification. The specification is given in linear-temporal logic. Like in previous approaches, we aim for a repaired program that satisfies the specification and is syntactically close to the faulty program. The novelty of our approach is that it produces a program that is also semantically close to the original program by enforcing that a subset of the original traces is preserved. Intuitively, the faulty program is considered to be a part of the specification, which enables us to synthesize meaningful repairs, even for incomplete specifications. Our approach is based on synthesizing a program with a set of behaviors that stay within a lower and an upper bound. We provide an algorithm to decide if a program is repairable with respect to our new notion, and synthesize a repair if one exists. We analyze several ways to choose the set of traces to leave intact and show the boundaries they impose on repairability. We also discuss alternative notions based on reward models to obtain repair systems that behave similar to the original system. We have evaluated the approach on several examples.

Runtime Enforcement of Security Policies on Black Box Reactive Programs

Security enforcement mechanisms like execution monitors are used to make sure that some untrusted program complies with a policy. Different enforcement mechanisms have different strengths and weaknesses and hence it is important to understand the qualities of various enforcement mechanisms. This paper studies runtime enforcement mechanisms for reactive programs. We study the impact of two important constraints that many practical enforcement mechanisms satisfy: (1) the enforcement mechanism must handle each input/output event in finite time and on occurrence of the event (as opposed to for instance Ligatti's edit automata that have the power to buffer events for an arbitrary amount of time), and (2) the enforcement mechanism treats the untrusted program as a black box : it can monitor and/or edit the input/output events that the program exhibits on execution and it can explore alternative executions of the program by running additional copies of the program and providing these different inputs. It can not inspect the source or machine code of the untrusted program. Such enforcement mechanisms are important in practice: they include for instance many execution monitors, virtual machine monitors, and secure multi-execution or shadow executions. We establish upper and lower bounds for the class of policies that are enforceable by such black box mechanisms, and we propose a generic enforcement mechanism that works for a wide range of policies. We also show how our generic enforcement mechanism can be instantiated to enforce specific classes of policies, at the same time showing that many existing enforcement mechanisms are optimized instances of our construction.

Моделирование и анализ поведения последовательных реагирующих программ

Finite state transducers extend the finite state automata to model functions on strings or lists. They may be used also as simple models of sequential reactive programs. These programs operate in the interaction with the environment permanently receiving data (requests) from it. At receiving a piece of data such program performs a sequence of actions. When certain control points are achieved a program outputs the current results of computation as a response. It is significant that different sequences of actions may yield the same result. Therefore, the basic actions of a program may be viewed as generating elements of some appropriate semigroup, and the result of computation may be regarded as the composition of actions performed by the program. This paper offers an alternative technique for the analysis of finite state transducers over semigroups. To check the equivalence of transducers and we associate with them a Labeled Transition Systems . Each path in this LTS represents all possible runs of and on the same input word. Every node of keeps track of the states of and achieved at reading some input word and the deficiency of the output words computed so far. If both transducers reach their final states and the deficiency of their outputs is nonzero then this indicates that and produce different images for the same word, and, hence, they are not equivalent. The nodes of that capture this effect are called rejecting nodes. Thus, the equivalence checking of and is reduced to checking the reachability of rejecting nodes in LTS . We show that one needs to analyze only a bounded fragment of to certify (un)reachability of rejecting nodes. The size of this fragment is polynomial of the size of and if both transducers are deterministic, and single-exponential if they are k-bounded. The same approach is applicable for checking k-valuedness of transducers over semigroups.

Rhenium Oxide based Olefin Metathesis

In support of a reactive distillation experimental program, bench scale experiments were conducted for the production of high molecular weight olefins via metathesis. A fixed bed rhenium oxide (Re2O7) catalyst on a γ-alumina support was utilized to study the reaction of C6, C8, and C10 olefins to form light and heavy olefin products. Initial experiments determined the impact temperature and weight hourly space velocity (WHSV) had on the reactivity of three different α- olefins. The investigated temperatures and WHSV were conditions that encompassed the anticipated reactive distillation column reactor zones temperatures and WHSV. All of these runs displayed high conversions, low selectivities, and significant secondary isomerization coupled with subsequent metathesis. This isomerization compromised the ability to make any quantitative assessments on the reactivity of olefins with respect to temperature, flow rate, and carbon number in the feed. However, it was concluded that there was a possible optimal co...

Reactive Imperative Programming with Dataflow Constraints

Dataflow languages provide natural support for specifying constraints between objects in dynamic applications, where programs need to react efficiently to changes in their environment. In this article, we show that one-way dataflow constraints, largely explored in the context of interactive applications, can be seamlessly integrated in any imperative language and can be used as a general paradigm for writing performance-critical reactive applications that require efficient incremental computations. In our framework, programmers can define ordinary statements of the imperative host language that enforce constraints between objects stored in special memory locations designated as “reactive.” Reactive objects can be of any legal type in the host language, including primitive data types, pointers, arrays, and structures. Statements defining constraints are automatically re-executed every time their input memory locations change, letting a program behave like a spreadsheet where the values of some variables depend on the values of other variables. The constraint-solving mechanism is handled transparently by altering the semantics of elementary operations of the host language for reading and modifying objects. We provide a formal semantics and describe a concrete embodiment of our technique into C/C++, showing how to implement it efficiently in conventional platforms using off-the-shelf compilers. We discuss common coding idioms and relevant applications to reactive scenarios, including incremental computation, observer design pattern, data structure repair, and software visualization. The performance of our implementation is compared to problem-specific change propagation algorithms, as well as to language-centric approaches such as self-adjusting computation and subject/observer communication mechanisms, showing that the proposed approach is efficient in practice.

Distributed REScala

Reactive programming improves the design of reactive applications by relocating the logic for managing dependencies between dependent values away from the application logic to the language implementation. Many distributed applications are reactive. Yet, existing change propagation algorithms are not suitable in a distributed setting. We propose Distributed REScala, a reactive language with a change propagation algorithm that works without centralized knowledge about the topology of the dependency structure among reactive values and avoids unnecessary propagation of changes, while retaining safety guarantees ( glitch freedom ). Distributed REScala enables distributed reactive programming, bringing the benefits of reactive programming to distributed applications. We demonstrate the enabled design improvements by a case study. We also empirically evaluate the performance of our algorithm in comparison to other algorithms in a simulated distributed setting.

An 8-week reactive balance training program in older healthy adults: A preliminary investigation

BackgroundThis preliminary study examined the effects of an 8-week supervised reactive balance training program on reaction time (RT) and foot speed, static balance and balance confidence in healthy older adults compared to an exercise control group. MethodsTwenty-five older adults were randomly assigned to a reactive balance training group (QuickBoard; n = 12; 71.0 ± 8.6 years) or a stationary cycling group (control; n = 13; 70.2 ± 6.0 years). Both groups were tested for foot RT foot speed, static balance, and balance confidence at baseline, 4-week, 8-week, and 4-week follow-up. ResultsResults indicated significant improvements in QuickBoard foot RT and speed in both groups with greater improvements in the QuickBoard group. However, no group difference was found in static balance performance. ConclusionAlthough the improvements in RT and foot speed may be beneficial for fall and trip prevention, the implications of the current findings for trip avoidance and performance of daily tasks are unclear.

Settable and non-interfering signal functions for FRP

Functional Reactive Programming (FRP) provides a method for programming continuous, reactive systems by utilizing signal functions that, abstractly, transform continuous input signals into continuous output signals. These signals may also be streams of events , and indeed, by allowing signal functions themselves to be the values carried by these events (in essence, signals of signal functions), one can conveniently make discrete changes in program behavior by "switching" into and out of these signal functions. This higher-order notion of switching is common among many FRP systems, in particular those based on arrows, such as Yampa. Although convenient, the power of switching is often an overkill and can pose problems for certain types of program optimization (such as causal commutative arrows [14]), as it causes the structure of the program to change dynamically at run-time. Without a notion of just-in-time compilation or related idea, which itself is beset with problems, such optimizations are not possible at compile time. This paper introduces two new ideas that obviate, in a predominance of cases, the need for switching. The first is a non-interference law for arrows with choice that allows an arrowized FRP program to dynamically alter its own structure (within statically limited bounds) as well as abandon unused streams. The other idea is a notion of a settable signal function that allows a signal function to capture its present state and later be restarted from some previous state. With these two features, canonical uses of higher-order switchers can be replaced with a suitable first-order design, thus enabling a broader range of static optimizations.

Poster - Thur Eve - 74: Distributed, asynchronous, reactive dosimetric and outcomes analysis using DICOMautomaton

Many have speculated about the future of computational technology in clinical radiation oncology. It has been advocated that the next generation of computational infrastructure will improve on the current generation by incorporating richer aspects of automation, more heavily and seamlessly featuring distributed and parallel computation, and providing more flexibility toward aggregate data analysis. In this report we describe how a recently created — but currently existing — analysis framework (DICOMautomaton) incorporates these aspects. DICOMautomaton supports a variety of use cases but is especially suited for dosimetric outcomes correlation analysis, investigation and comparison of radiotherapy treatment efficacy, and dose-volume computation. We describe: how it overcomes computational bottlenecks by distributing workload across a network of machines; how modern, asynchronous computational techniques are used to reduce blocking and avoid unnecessary computation; and how issues of out-of-date data are addressed using reactive programming techniques and data dependency chains. We describe internal architecture of the software and give a detailed demonstration of how DICOMautomaton could be used to search for correlations between dosimetric and outcomes data.

Analyzing program behavior through active automata learning

The objective of the RERS Challenge 2013 was to analyze program behavior with respect to given sets of LTL and reachability properties for a set of reactive programs. The programs in various sizes and complexities could be divided into three different categories, depending on the available information: from black-box (binary-only) to white-box (full source code) over a mixed form thereof (grey-box). In this paper we present our approach to tackling the challenge problems, which is based on active automata learning. This required extending automata learning algorithms to exploit the given information, and adapting them in order to overcome problem-specific obstacles. We describe general optimizations and discuss the achieved results.

The nesC language

We present nesC, a programming language for networked embedded systems that represent a new design space for application developers. An example of a networked embedded system is a sensor network, which consists of (potentially) thousands of tiny, lowpower "motes," each of which execute concurrent, reactive programs that must operate with severe memory and power constraints. nesC's contribution is to support the special needs of this domain by exposing a programming model that incorporates event-driven execution, a flexible concurrency model, and component-oriented application design. Restrictions on the programming model allow the nesC compiler to perform whole-program analyses, including data-race detection (which improves reliability) and aggressive function inlining (which reduces resource consumption). nesC has been used to implement TinyOS, a small operating system for sensor networks, as well as several significant sensor applications. nesC and TinyOS have been adopted by a large number of sensor network research groups, and our experience and evaluation of the language shows that it is effective at supporting the complex, concurrent programming style demanded by this new class of deeply networked systems.

Categorical Semantics for Functional Reactive Programming with Temporal Recursion and Corecursion

Functional reactive programming (FRP) makes it possible to express temporal aspects of computations in a declarative way. Recently we developed two kinds of categorical models of FRP: abstract process categories (APCs) and concrete process categories (CPCs). Furthermore we showed that APCs generalize CPCs. In this paper, we extend APCs with additional structure. This structure models recursion and corecursion operators that are related to time. We show that the resulting categorical models generalize those CPCs that impose an additional constraint on time scales. This constraint boils down to ruling out $\omega$-supertasks, which are closely related to Zeno's paradox of Achilles and the tortoise.

Reactive Programming for Interactive Graphics

One of the big challenges of developing interactive statistical applications is the management of the data pipeline, which controls transformations from data to plot. The user's interactions needs to be propagated through these modules and reflected in the output representation at a fast pace. Each individual module may be easy to develop and manage, but the dependency structure can be quite challenging. The MVC (Model/View/Controller) pattern is an attempt to solve the problem by separating the user's interaction from the representation of the data. In this paper we discuss the paradigm of reactive programming in the framework of the MVC architecture and show its applicability to interactive graphics. Under this paradigm, developers benefit from the separation of user interaction from the graphical representation, which makes it easier for users and developers to extend interactive applications. We show the central role of reactive data objects in an interactive graphics system, implemented as the R package cranvas, which is freely available on GitHub and the main developers include the authors of this paper.

Reactive Molecular Dynamics Simulation on the Disintegration of Kapton, POSS Polyimide, Amorphous Silica, and Teflon during Atomic Oxygen Impact Using the Reaxff Reactive Force-Field Method

Atomic oxygen (AO) is the most abundant element in the low Earth orbit (LEO). It is the result of the dissociation of molecular oxygen by ultraviolet radiation from the sun. In the LEO, it collides with the materials used on spacecraft surfaces and causes degradation of these materials. The degradation of the materials on the surface of spacecrafts at LEO has been a significant problem for a long time. Kapton polyimide, polyhedral oligomeric silsesquioxane (POSS), silica, and Teflon are the materials extensively used in spacecraft industry, and like many other materials used in spacecraft industry, AO collision degradation is an important issue in their applications on spacecrafts. To investigate the surface chemistry of these materials in exposure to space AO, a computational chemical evaluation of the Kapton polyimide, POSS, amorphous silica, and Teflon was performed in separate simulations under similar conditions. For performing these simulations, the ReaxFF reactive force-field program was used, which provides the computational speed required to perform molecular dynamics (MD) simulations on system sizes sufficiently large to describe the full chemistry of the reactions. Using these simulations, the effects of AO impact on different materials and the role of impact energies, the content of material, and temperature of material on the behavior of the materials are studied. The ReaxFF results indicate that Kapton is less resistant than Teflon toward AO damage. These results are in good agreement with experiment. These simulations indicate that the amorphous silica shows the highest stability among these materials before the start of the highly exothermic silicon oxidation. We have verified that adding silicon to the bulk of the Kapton structure enhances the stability of the Kapton against AO impact. Our canonical MD simulations demonstrate that an increase in the heat transfer in materials during AO impact can provide a considerable decrease in the disintegration of the material. This effect is especially relevant in silica AO collision. Considerable experimental efforts have been undertaken to minimize such AO-based degradations. As our simulations demonstrate, ReaxFF can provide a cost-effective screening tool for future material optimization.

Optimization and Minimization of Disturbance to the Operating Room

Requests for surgical surgery can occur unexpectedly. We can not, in any circumstances when the demand for care arises.Some requests can be queued and scheduled for future dates. These applications are generally surgeries that are not of an urgent nature, they can be delayed without danger to the patient. In medical language, this type of application is generally designated b y the elective surgery, or scheduled.However, a significant proportion of applications within the field of emergency and requires immediate care. This type of application is inherently difficult to predict, and therefore not schedulable and is generally d esignated by the emergency surgery. Depending on the legal structure of the hospital, it may be obliged to accept all emergency patients In this paper, we study the problem of reactive scheduling surgeries in operating rooms with consideration arriving urgent cases.In this context, we propose a reactive programming model procedure whose purpose is to minimize the cost of inserting these urgent cases and also take in consideration the availability of o perating theaters and Surgeons. To solve this problem, we propose a heuristic based on constraint programming

Fair reactive programming

Functional Reactive Programming (FRP) models reactive systems with events and signals, which have previously been observed to correspond to the "eventually" and "always" modalities of linear temporal logic (LTL). In this paper, we define a constructive variant of LTL with least fixed point and greatest fixed point operators in the spirit of the modal mu-calculus, and give it a proofs-as-programs interpretation as a foundational calculus for reactive programs. Previous work emphasized the propositions-as-types part of the correspondence between LTL and FRP; here we emphasize the proofs-as-programs part by employing structural proof theory. We show that the type system is expressive enough to enforce liveness properties such as the fairness of schedulers and the eventual delivery of results. We illustrate programming in this calculus using (co)iteration operators. We prove type preservation of our operational semantics, which guarantees that our programs are causal. We give also a proof of strong normalization which provides justification that our programs are productive and that they satisfy liveness properties derived from their types.

A constraint-based approach to solving games on infinite graphs

We present a constraint-based approach to computing winning strategies in two-player graph games over the state space of infinite-state programs. Such games have numerous applications in program verification and synthesis, including the synthesis of infinite-state reactive programs and branching-time verification of infinite-state programs. Our method handles games with winning conditions given by safety, reachability, and general Linear Temporal Logic (LTL) properties. For each property class, we give a deductive proof rule that --- provided a symbolic representation of the game players --- describes a winning strategy for a particular player. Our rules are sound and relatively complete. We show that these rules can be automated by using an off-the-shelf Horn constraint solver that supports existential quantification in clause heads. The practical promise of the rules is demonstrated through several case studies, including a challenging "Cinderella-Stepmother game" that allows infinite alternation of discrete and continuous choices by two players, as well as examples derived from prior work on program repair and synthesis.

Utilisation bounds of P-FRP tasks

Priority-based functional reactive programming (P-FRP) is a new functional programming formalism for developing safety-critical embedded systems. P-FRP allows static priority assignment and guarantees real-time response by preempting lower priority tasks. Due to the state-less nature of functional programmes, preempted tasks in P-FRP are aborted and have to restart after the higher priority tasks have completed execution. Since the execution semantics of P-FRP are different from the classical preemptive model of execution, existing utilisation-based sufficient conditions cannot be applied. In this paper, we derive a new utilisation-based sufficient schedulability condition for P-FRP, and validate it using experimental task sets. We then compare the sufficient schedulability condition of P-FRP with that of the preemptive model to demonstrate the severe restrictions on task set sizes in P-FRP. Effect on the utilisation bound under conditional preemption has also been analysed.