Future of Functional Reactive Programming in Real-Time Systems

The evolution of programming paradigms and the development of new programming languages are driven by the needs of problem domains. Functional reactive programming (FRP) combines functional programming (FP) and reactive programming (RP) concepts that leverage asynchronous dataflow from reactive programming and higher-level abstractions building blocks from functional programming to enable developers to define data flows and transformations declaratively. Declarative programming allows developers to concentrate more on the problem to be solved rather than the implementation details, resulting in efficient and concise code. Over the years, various FRP designs have been proposed in real-time application areas. Still, it remains unclear how FRP-based solutions compare with traditional methods for implementing these applications. In this survey, we studied the usefulness of FRP in some real-time applications, such as game development, animation, graphical user interface(GUI), and embedded system. We conducted a qualitative comparison for game development and studied various applications in animation, GUI, and embedded systems. We found that using FRP in these applications is quite difficult because of insufficient libraries and tools. Additionally, due to high learning curves and a need for experienced developers, the development process in FRP takes time and effort. Our examination of two well-known games: Asteroid and Pong, in three programming paradigms: imperative programming using the Unity game engine, FP in Haskell, and FRP in the Yampa library, showed that imperative programming is effective in terms of performance and usability. The other two paradigms for developing games from scratch are inefficient and challenging. Despite the fact that FRP was designed for animation, the majority of its applications are underperforming. FRP is more successful for GUI applications, where libraries like RxJS have been used in many web interfaces. FRP is also applied in developing embedded system applications for its effective memory management, maintainability, and predictability. Developing efficient solutions from scratch is not suitable in FRP due to several factors, such as poor performance compared to other programming paradigms, programming complexity, and a steep learning curve. Instead, developers can be benefited from utilizing FRP-supported modular platforms to build robust and scalable real-time applications

Debugging for reactive programming

Reactive programming is a recent programming technique that provides dedicated language abstractions for reactive software. Reactive programming relieves developers from manually updating outputs when the inputs of a computation change, it overcomes a number of well-know issues of the Observer design pattern, and it makes programs more comprehensible. Unfortunately, complementing the new paradigm with proper tools is a vastly unexplored area. Hence, as of now, developers can embrace reactive programming only at the cost of a more challenging development process. In this paper, we investigate a primary issue in the field: debugging programs in the reactive style. We analyze the problem of debugging reactive programs, show that the reactive style requires a paradigm shift in the concepts needed for debugging, and propose RP Debugging, a methodology for effectively debugging reactive programs. These ideas are implemented in Reactive Inspector, a debugger for reactive programs integrated with the Eclipse Scala IDE. Evaluation based on a controlled experiment shows that RP Debugging outperforms traditional debugging techniques