New Debugging Framework Bridges Gap Between FRP Language and Embedded C Code

Embedded systems developers working with Emfrp, a functional reactive programming (FRP) language, typically face a debugging challenge: their high-level FRP source code is translated into C, then combined with platform-specific I/O routines in C or C++, but existing debuggers like GDB can only operate at the compiled code level. This mismatch makes it difficult to reason about program behavior in terms of the original FRP abstractions.

The Abstraction Gap Problem#

Emfrp uses time-varying values as its core abstraction for describing reactive behavior in small-scale embedded systems. While this approach produces more concise and maintainable application logic, it creates a widening gap between what developers think about (FRP concepts) and what they can inspect during debugging (raw C/C++ instructions and memory). Developers must mentally map between the two levels, a time-consuming and error-prone process.

Multi-Mode Debugging Solution#

Researchers have designed a debugging framework that operates on multiple levels simultaneously. The system leverages source code mapping—a technique that tracks which parts of the compiled program correspond to which Emfrp constructs. This allows debuggers to:

• Step through and inspect program execution using FRP-level abstractions
• Switch to examining the underlying C/C++ implementation when needed
• Correlate high-level reactive behavior with low-level platform-specific code

Validation and Results#

The team validated their approach on an ESP32 microcontroller using typical embedded debugging scenarios. Testing demonstrated that the framework significantly reduces the time and mental overhead required to understand where bugs originate—whether in the FRP logic layer or the hardware-dependent I/O components.

Why It Matters#

As FRP languages gain adoption for systems programming, tools that maintain abstraction while supporting low-level inspection become essential. This work signals growing recognition that effective debugging requires bridging, not abandoning, the gap between domain-specific languages and their compiled targets.