Reactive Programming Language Research Articles

Tracking the Neurodegeneration and Behavioral Changes in Mice Model of Prodromal Phase Alpha-Synucleinopathy


 
 
 Background:
 The aggregation of misfolded alpha-synuclein (αSyn) has been shown to cause neurodegeneration in a mouse model and lead to behavioral changes. While others have examined end-stage (after neurodegeneration has set in) behavioral changes in mice after αSyn preformed fibrils (PFF) seeding, the precise timeline of circuit changes and associated behavioral deficits during the prodromal phase of synucleinopathic spread is poorly understood. We set out to measure and characterize the extent to which behavior is affected by primary motor cortex (M1) PFF seeding in mice.
 Experimental Design:
 We quantified the neuronal cell body density at M1 layers 2/3 and 5 using immunohistochemistry cell assays to determine if there were neurodegenerative effects under the PFF seeding strategy. Furthermore, using Bonsai, a visual reactive programming language, we tracked the behavior of the PFF seeded mice for exploratory motives, decreases in which can be used to show cognitive decline. To further ascertain the effect of αSyn on vulnerable excitatory pathways in the cortex, we performed prodromal injections of αSyn PFF into the M1 of ChATCre mice along with projection tracing in the basal forebrain.
 Results:
 During the first 3 months following PFF seeding, the density of neuronal cell bodies in M1 layers 2/3 and 5 remains unchanged in PFF seeded mice compared to control mice. The exploratory index of PFF seeded mice was comparable to that of control mice. These results suggest insignificant neurodegeneration and behavioral change in the first 3 months following PFF seeding.
 Conclusion:
 Work done previously in this lab tracking the spread of PFF in M1 shows significant spread of αSyn for 3 months following prodromal injection. The results from this work show that there is little neurodegeneration or behavioral change in that timeframe despite the significant spread of αSyn. Future work hinges on further probing this phenomenon.
 
 

Topology-Level Reactivity in Distributed Reactive Programs

Reactive programming is a popular paradigm to program event-driven applications, and it is often proposed as a paradigm to write distributed applications. One such type of application is *prosumer* applications, which are distributed applications that both produce and consume many events. We analyse the problems that occur when using a reactive programming language or framework to implement prosumer applications. We find that the assumption of an open network, which means prosumers of various types spontaneously join and leave the network, can cause a lot of code complexity or run-time inefficiency. At the basis of these issues lies *acquaintance management*: the ability to discover prosumers as they join and leave the network, and correctly maintaining this state throughout the reactive program. Most existing reactive programming languages and frameworks have limited support for managing acquaintances, resulting in accidental complexity of the code or inefficient computations. In this paper we present acquaintance management for reactive programs. First, we design an *acquaintance discovery* mechanism to create a *flock* that automatically discovers prosumers on the network. An important aspect of flocks is their integration with reactive programs, such that a reactive program can correctly and efficiently maintain its state. To this end we design an *acquaintance maintenance* mechanism: a new type of operator for functional reactive programming languages that we call `deploy-*`. The `deploy-*` operator enables correct and efficient reactions to time-varying collections of discovered prosumers. The proposed mechanisms are implemented in a reactive programming language called Stella, which serves as a linguistic vehicle to demonstrate the ideas of our approach. Our implementation of acquaintance management results in computationally efficient and idiomatic reactive code. We evaluate our approach quantitatively via benchmarks that show that our implementation is efficient: computations will efficiently update whenever a new prosumer is discovered, or a connected prosumer is dropped. To evaluate the distributed capabilities of our prototype implementation, we implement a use-case that simulates the bike-sharing infrastructure of Brussels, and we run it on a Raspberry Pi cluster computer. We consider our work to be an important step to use functional reactive programming to build distributed systems for open networks, in other words, distributed reactive programs that involve many prosumer devices and sensors that spontaneously join and leave the network.

A Functional Reactive Programming Language for Small-Scale Embedded Systems with Recursive Data Types

A Functional Reactive Programming Language for Small-Scale Embedded Systems with Recursive Data Types

ReactiFi: Reactive Programming of Wi-Fi Firmware on Mobile Devices

Network programmability will be required to handle future increased network traffic and constantly changing application needs. However, there is currently no way of using a high-level, easy to use programming language to program Wi-Fi firmware. This impedes rapid prototyping and deployment of novel network services/applications and hinders continuous performance optimization in Wi-Fi networks, since expert knowledge is required for both the used hardware platforms and the Wi-Fi domain. In this paper, we present ReactiFi, a high-level reactive programming language to program Wi-Fi chips on mobile consumer devices. ReactiFi enables programmers to implement extensions of PHY, MAC, and IP layer mechanisms without requiring expert knowledge of Wi-Fi chips, allowing for novel applications and network protocols. ReactiFi programs are executed directly on the Wi-Fi chip, improving performance and power consumption compared to execution on the main CPU. ReactiFi is conceptually similar to functional reactive languages, but is dedicated to the domain-specific needs of Wi-Fi firmware. First, it handles low-level platform-specific details without interfering with the core functionality of Wi-Fi chips. Second, it supports static reasoning about memory usage of applications, which is important for typically memory-constrained Wi-Fi chips. Third, it limits dynamic changes of dependencies between computations to dynamic branching, in order to enable static reasoning about the order of computations. We evaluate ReactiFi empirically in two real-world case studies. Our results show that throughput, latency, and power consumption are significantly improved when executing applications on the Wi-Fi chip rather than in the operating system kernel or in user space. Moreover, we show that the high-level programming abstractions of ReactiFi have no performance overhead compared to manually written C code.

A Semantic Framework for the Design of Distributed Reactive Real-Time Languages and Applications

The proliferation of on-demand internet services delivered over a network of a heterogeneous set of computing devices has created the need for high-performing dynamic systems in real-time. Services such as audio and video streaming, self-driving cars, the Internet of things (IoT), or instant communication on social networks have forced system designers to rethink the architectures and tools for implementing computer systems. Reactive programming has been advocated as a programming paradigm suitable for implementing dynamic applications with complex and heterogeneous architectural needs. However, there is no consensus on the core set of features that a reactive framework must-have. Furthermore, the current set of features proposed in reactive tools seems very restricted to cope with the actual needs for concurrency and distribution in modern systems. In this paper, several alternative semantics for distributed reactive languages are investigated, addressing complex open issues such as glitch avoidance, explicit distribution support, and constructs for explicit time management. First, we propose a reactive event-based programming language with explicit support for distribution, concurrency, and explicit time manipulation (ReactiveXD). Second, we present a reactive event-based semantic framework called Distributed Reactive Rewriting Framework (DRRF). The framework uses rewriting logic to model the components of a distributed base application, observables, and observers, and predicates supporting explicit time manipulation. Finally, to validate the proposal, the paper discusses the specification of the semantics of ReactiveXD and a scenario describing a case of intrusion detection on IoT networks.

On Rapid Development of Reactive Wireless Sensor Systems

Abstract We present a software platform for designing and testing wireless networks of sensors and actuators (WSNs). The platform consists of three components: an operating system for small-footprint microcontrollers (dubbed PicOS), a software development kit (SDK) amounting to a C-based, event-oriented (reactive) programming language, and a virtual execution platform (VUE2) capable of emulating complete deployment environments for WSNs and thus facilitating their rapid development.1 Its most recent incarnation introduced in the present paper is a component of the WSN lab being currently set up at Vistula in collaboration with Olsonet Communications Corporation.2 We highlight the platform’s most interesting features within the context of a production WSN installed at independent-living facilities.

Distributed Reactive Programming for Reactive Distributed Systems

Context: The term reactivity is popular in two areas of research: programming languages and distributed systems. On one hand, reactive programming is a paradigm which provides programmers with the means to declaratively write event-driven applications. On the other hand, reactive distributed systems handle client requests in a timely fashion regardless of load or failures. Inquiry: Reactive programming languages and frameworks tailored to the implementation of distributed systems have previously been proposed. However, we argue that these approaches are ill fit to implement reactive distributed systems. Approach: We analyse state of the art runtimes for distributed reactive programming and identify two key issues with regards to reactive distributed systems. They rely on single, central points of coordination and/or assume a lack of partial failures in the systems they support. Knowledge: Based on our analysis we propose a novel runtime for distributed reactive programming languages and frameworks. This runtime supports reactive distributed systems by design. Grounding: We implement a proof of concept framework for reactive distributed systems in JavaScript which builds atop our runtime. Using this framework we implement a case study application which highlights the applicability of our approach. Moreover, we benchmark our runtime against a similar approach in order to showcase its runtime properties and we prove its correctness. Importance: This work aims to bridge the gap between two kinds of reactivity: reactive distributed systems and distributed reactive programming. Current distributed reactive programming approaches do not support reactive distributed systems. Our runtime is the first to bridge this reactivity gap: it allows for reactive distributed systems to be implemented using distributed reactive programming.

Harmonizing Signals and Events with a Lightweight Extension to Java

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

Scheduling Globally Asynchronous Locally Synchronous Programs for Guaranteed Response Times

Safety-critical software systems need to guarantee functional correctness and bounded response times to external input events. Programs designed using reactive programming languages, based on formal mathematical semantics, can be automatically verified for functional correctness guarantees. Real-time guarantees on the other hand are much harder to achieve. In this article we provide a static analysis framework for guaranteeing response times for reactive programs developed using the Globally Asynchronous Locally Synchronous (GALS) model of computation. The proposed approach is applicable to scheduling of GALS programs for different target architectures with single or multiple processors or cores. A Satisfiability Modulo Theory (SMT) formulation in the quantifier free linear real arithmetic (QF_LRA) logic is used for scheduling. A novel technique to encode rendezvous used in synchronization of globally asynchronous processes in the presence of locally synchronous parallelism and arbitrary preemption into QF_LRA logic is presented. Finally, our SMT formulation is shown to produce schedules in reasonable time.

Integrating discrete controller synthesis into a reactive programming language compiler

We define a mixed imperative/declarative programming language: declarative contracts are enforced upon imperatively described behaviors. This paper describes the semantics of the language, making use of the notion of Discrete Controller Synthesis (DCS). We target the application domain of adaptive and reconfigurable systems: our language can serve programming closed-loop adaptation controllers, enabling flexible execution of functionalities w.r.t. changing resource and environment conditions. DCS is integrated into a1 programming language compiler, which facilitates its use by users and programmers, performing executable code generation. The tool is concretely built upon the basis of a reactive programming language compiler, where the nodes describe behaviors that can be modeled in terms of transition systems. Our compiler integrates this with a DCS tool, making it a new environment for formal methods. We define the trace semantics of our contracts language, describe its compilation and establish its correctness, and discuss implementation and examples.

Discrete supervisory control application to computing systems administration

A recent and novel research movement has seen the application of Control Theory and Techniques to the administration of computing systems, in a closed-loop management. While most previous works rely on continuous models, we more originally consider the issues that can be posed and solved as discrete supervisory control problems. We adopt a tool-based approach, with a reactive programming language, and its compiler based on discrete controller synthesis (DCS). We illustrate our approach on networks and servers management problems.

Higher-order functional reactive programming in bounded space

Functional reactive programming (FRP) is an elegant and successful approach to programming reactive systems declaratively. The high levels of abstraction and expressivity that make FRP attractive as a programming model do, however, often lead to programs whose resource usage is excessive and hard to predict. In this paper, we address the problem of space leaks in discrete-time functional reactive programs. We present a functional reactive programming language that statically bounds the size of the dataflow graph a reactive program creates, while still permitting use of higher-order functions and higher-type streams such as streams of streams. We achieve this with a novel linear type theory that both controls allocation and ensures that all recursive definitions are well-founded. We also give a denotational semantics for our language by combining recent work on metric spaces for the interpretation of higher-order causal functions with length-space models of space-bounded computation. The resulting category is doubly closed and hence forms a model of the logic of bunched implications.

Automatic generation of discrete handlers of real-time continuous control tasks

AbstractWe present a novel technique for designing discrete, logical control loops, on top of continuous control tasks, ensuring logical safety properties of the tasks sequencings and mode changes. We define this new handler on top of the real-time executives built with the Orccad design environment for control systems, which is applied, e.g. to robotics and real-time networked control. It features structures of control tasks, each equipped with a local automaton, used for the reactive, event-based management of its activity and modes. The additional discrete handler manages the interactions between tasks, concerning, e.g., mutual exclusions, forbidden or imposed sequences. We use a new reactive programming language, with constructs for finite-state machines and data-flow nodes, and a mechanism of behavioral contracts, which involves discrete controller synthesis. The result is a discrete control loop, on top of the continuous control loops, all integrated in a coherent real-time architecture. Our approach is illustrated and validated experimentally with the case study of a robot arm.

Contracts for modular discrete controller synthesis

We describe the extension of a reactive programming language with a behavioral contract construct. It is dedicated to the programming of reactive control of applications in embedded systems, and involves principles of the supervisory control of discrete event systems. Our contribution is in a language approach where modular discrete controller synthesis (DCS) is integrated, and it is concretized in the encapsulation of DCS into a compilation process. From transition system specifications of possible behaviors, DCS automatically produces controllers that make the controlled system satisfy the property given as objective. Our language features and compiling technique provide correctness-by-construction in that sense, and enhance reliability and verifiability. Our application domain is adaptive and reconfigurable systems: closed-loop adaptation mechanisms enable flexible execution of functionalities w.r.t. changing resource and environment conditions. Our language can serve programming such adaption controllers. This paper particularly describes the compilation of the language. We present a method for the modular application of discrete controller synthesis on synchronous programs, and its integration in the BZR language. We consider structured programs, as a composition of nodes, and first apply DCS on particular nodes of the program, in order to reduce the complexity of the controller computation; then, we allow the abstraction of parts of the program for this computation; and finally, we show how to recompose the different controllers computed from different abstractions for their correct co-execution with the initial program. Our work is illustrated with examples, and we present quantitative results about its implementation.

Dynamic Controllability of Temporally-flexible Reactive Programs

In this paper we extend dynamic controllability of temporally-flexible plans to temporally-flexible reactive programs. We consider three reactive programming language constructs whose behavior depends on runtime observations; conditional execution, iteration, and exception handling. Temporally-flexible reactive programs are distinguished from temporally-flexible plans in that program execution is conditioned on the runtime state of the world. In addition, exceptions are thrown and caught at runtime in response to violated timing constraints, and handled exceptions are considered successful program executions. Dynamic controllability corresponds to a guarantee that a program will execute to completion, despite runtime constraint violations and uncertainty in runtime state. An algorithm is developed which frames the dynamic controllability problem as an AND/OR search tree over possible program executions. A key advantage of this approach is the ability to enumerate only a subset of possible program executions that guarantees dynamic controllability, framed as an AND/OR solution subtree.

Conflict-directed A * and its role in model-based embedded systems

Artificial Intelligence has traditionally used constraint satisfaction and logic to frame a wide range of problems, including planning, diagnosis, cognitive robotics and embedded systems control. However, many decision making problems are now being re-framed as optimization problems, involving a search over a discrete space for the best solution that satisfies a set of constraints. The best methods for finding optimal solutions, such as A *, explore the space of solutions one state at a time. This paper introduces conflict-directed A * , a method for solving optimal constraint satisfaction problems. Conflict-directed A * searches the state space in best first order, but accelerates the search process by eliminating subspaces around each state that are inconsistent. This elimination process builds upon the concepts of conflict and kernel diagnosis used in model-based diagnosis [J. de Kleer, B.C. Williams, Diagnosing multiple faults, Artif. Intell. 32(1) (1987) 97–130; J. de Kleer, A. Mackworth, R. Reiter, Characterizing diagnoses and systems, Artif. Intell. 56 (1992) 197–222] and in dependency-directed search [R. Stallman, G.J. Sussman, Forward reasoning and dependency-directed backtracking in a system for computer-aided circuit analysis, Artif. Intell. 9 (1977) 135–196; J. Gaschnig, Performance measurement and analysis of certain search algorithms, Technical Report CMU-CS-79-124, Carnegie-Mellon University, Pittsburgh, PA, 1979; J. de Kleer, B.C. Williams, Back to backtracking: controlling the ATMS, in: Proceedings of AAAI-86, 1986, pp. 910–917; M. Ginsberg, Dynamic backtracking, J. Artif. Intell. Res. 1 (1993) 25–46]. Conflict-directed A * is a fundamental tool for building model-based embedded systems, and has been used to solve a range of problems, including fault isolation [J. de Kleer, B.C. Williams, Diagnosing multiple faults, Artif. Intell. 32(1) (1987) 97–130], diagnosis [J. de Kleer, B.C. Williams, Diagnosis with behavioral modes, in: Proceedings of IJCAI-89, 1989, pp. 1324–1330], mode estimation and repair [B.C. Williams, P. Nayak, A model-based approach to reactive self-configuring systems, in: Proceedings of AAAI-96, 1996, pp. 971–978], model-compilation [B.C. Williams, P. Nayak, A reactive planner for a model-based executive, in: Proceedings of IJCAI-97, 1997] and model-based programming [M. Ingham, R. Ragno, B.C. Williams, A reactive model-based programming language for robotic space explorers, in: Proceedings of ISAIRAS-01, 2001].

Model-based programming of fault-aware systems

A wide range of sensor-rich, networked embedded systems are being created that must operate robustly for years in the face of novel failures by managing complex autonomic processes. These systems are being composed, for example, into vast networks of space, air, ground, and underwater vehicles. Our objective is to revolutionize the way in which we control these new artifacts by creating reactive model-based programming languages that enable everyday systems to reason intelligently and enable machines to explore other worlds. A model-based program is state and fault aware; it elevates the programming task to specifying intended state evolutions of a system. The program's executive automatically coordinates system interactions to achieve these states, entertaining known and potential failures, using models of its constituents and environment. At the executive's core is a method, called CONFLICT-DIRECTED A*, which quickly prunes promising but infeasible solutions, using a form of one-shot learning. This approach has been demonstrated on a range of systems, including the National Aeronautics and Space Administration's Deep Space One probe. Model-based programming is being generalized to hybrid discrete-continuous systems and the coordination of networks of robotic vehicles.

Model-based programming of intelligent embedded systems and robotic space explorers

Programming complex embedded systems involves reasoning through intricate system interactions along lengthy paths between sensors, actuators, and control processors. This is a challenging, time-consuming, and error-prone process requiring significant interaction between engineers and software programmers. Furthermore, the resulting code generally lacks modularity and robustness in the presence of failure. Model-based programming addresses these limitations, allowing engineers to program reactive systems by specifying high-level control strategies and by assembling commonsense models of the system hardware and software. In executing a control strategy, model-based executives reason about the models on the fly, to track system state, diagnose faults, and perform reconfigurations. This paper develops the reactive model-based programming language (RMPL) and its executive, called Titan. RMPL provides the features of synchronous, reactive languages, with the added ability of reading and writing to state variables that are hidden within the physical plant being controlled. Titan executes an RMPL program using extensive component-based declarative models of the plant to track states, analyze anomalous situations, and generate novel control sequences. Within its reactive control loop, Titan employs propositional inference to deduce the system's current and desired states, and it employs model-based reactive planning to move the plant from the current to the desired state.

BDL: a specialized language for per-object reactive control

The problem of describing the concurrent behavior of objects in object oriented languages is addressed. The approach taken is to let methods be the behavior units whose synchronization is controlled separate from their specification. Our proposal is a domain-specific language called BDL for expressing constraints on this control and actually implementing its enforcement. We propose a model where each object includes a so-called "execution controller", programmed in BDL. This separates cleanly the concepts of what the methods do, the object processes, from the circumstances in which they are allowed to do it, the control. The object controller ensures that scheduling constraints between the object's methods are met. Aggregate objects can be controlled in terms of their components. This language has a convenient formal base. Thus, using BDL expressions, behavioral properties of objects or groups of interesting objects can be verified. Our approach allows, for example, deadlock detection or verification of safety properties, while maintaining a reasonable code size for the running controller. A compiler from BDL has been implemented, automatically generating controller code in an Esterel program, i.e., in a reactive programming language. From this code, the Esterel compiler, in turn, generates an automaton on which verifications are done. Then this automaton is translated into a C code to be executed. This multistage process typifies the method for successful use of a domain-specific language. This also allows high level concurrent programming.

Mission control of the MARIUS autonomous underwater vehicle: system design, implementation and sea trials

This paper describes the design and implementation of a mission control system for the MARIUS autonomous underwater vehicle (AUV). The framework adopted for system design builds on the key concept of vehicle primitive, which is a parametrized specification of an elementary operation performed by the vehicle. Vehicle primitives are obtained by coordinating the execution of a number of concurrent system tasks, which are parametrized specifications of classes of algorithms or procedures that implement basic functionalities in an underwater robotic system. Vehicle primitives are in turn logically and temporally chained to form more abstract mission procedures, which are executed as determined by mission programs, in reaction to external events. System task design is carried out using well-established tools from continuous- or discrete-time dynamic system theory, and finite-state automata to describe their logical (event-based) interaction with vehicle primitives. The design and analysis of vehicle primitives and mission procedures build on the theory of Petri nets, which are naturally oriented towards the modeling and analysis of asynchronous concurrent discrete-event systems. Vehicle primitives and mission procedures can be developed and implemented on the vehicle's distributed computer system using the specially designed software programming environments CORAL and ATOL respectively. The first is a set of software tools that allows for graphically building a library of vehicle primitives embodied in Petri nets and running them in real time. The latter provides similar tools for mission procedure programming but relies on a reactive synchronous programming language as a way to manage the potential complexity introduced by the occurrence of large Petri net structures. Whereas the first has been fully implemented, the latter has been specified but is still under development. Thus, at this stage of development, mission procedures and mission programs are effectively embodied into higher-level Petri net structures that control the scheduling of the vehicle primitives that are necessary to execute a given mission. The paper provides a summary of the general methodology adopted for the design and implementation of mission control systems for underwater robots and describes its application to the control of the MARIUS AUV. The paper introduces the experimental set-up for mission programming, mission execution and mission follow-up from a support station and describes the sequence of steps involved in programming and running a selected mission with the vehicle at sea.