## 2 State of the Art  
In this section, the authors discuss the state of the art of existing methodologies and frameworks enabling dynamic reconfiguration, as well as examples of existing framework implementations as preparation for approaching the development of the proposal of this paper. With the gradual shift towards agile methodologies and processes for Continuous Integration and Continuous Deployment (referred to as CI/CD) in project workflows for embedded systems, there has been an increasing demand for dynamic environments that facilitate the efficient and straightforward execution of test scripts, dynamic code evaluation, and results analysis. Developing correct and efficient programs for microcontrollers is highly challenging and time-consuming. Microcontrollers are typically programmed in low-level languages such as C, which makes debugging and maintenance difficult [14]. Furthermore, their constraints and minimalism often negatively impact the development lifecycle, hindering development teams from fully adopting an agile approach for several key reasons:  
* Agile methodologies advocate for a flexible approach with rapid responses to client requirements. This is not easily achievable by directly modifying the firmware of devices, which would instead require updates or system recompilation, introducing additional delays that not only slow down system response but also hinder the critical testing and verification process necessary for continuous integration. Additionally, the development cycle is inherently long and slow, as even minor changes require a complete re-run of the entire outlined process [10]. * System debugging limitations pose additional challenges. Most debugging tools cover only the most popular platforms and can impact the reliability and objectivity of performance testing results. In such situations, development teams often rely on logging messages and microcontroller states with data on resource usage, though this approach still fails to provide detailed insights into the system's status and operation [4]. * Low-level microcontroller setup, where component initialization errors and memory management issues are frequent, can lead to system crashes without clear error information. Error data and interrupt signals are commonly presented in the form of stack and memory dumps, which further slow system verification down due the need to reproduce the error, analyse feedback data, and finally identify the cause. These drawbacks not only hinder production software recovery in response to user feedback, but also disrupt the entire CI/CD pipeline for complex systems [14]. Some of these obstacles can be mitigated by using one of the high-level programming languages available for microcontroller programming. Their dynamic and often interpreted nature provides flexible, incremental changes in support of virtual platforms and CI/CD, offering a range of auxiliary tools and APIs for remote debugging, system monitoring, and instance state management. However, while these languages offer greater abstraction for microcontroller programming, they also introduce a new set of issues: debugging support often relies on using \"print\" statements, the language runtime consumes substantial onchip space regardless of functionality used, and they are considerably slower than low-level languages, making driver development for devices inefficient [4]. Nevertheless, embedded system development is a matter of compromise: high-level languages simplify development and maintenance, enabling faster iterations and reducing complexity, though at the cost of reduced performance and increased memory demands. The world of microcontrollers and programming languages for their development has undergone significant growth and application. A wide range of programming languages have been adapted for various hardware platforms, such as Forth, BASIC, Java, Python, Lua, and more [2].