We introduce software architecture for embedded, real-time monitoring systems. The architecture is based both upon sound software engineering principles and industrial experience in the application domain.

The design of object-oriented real-time distributed systems is especially hard due to the fact that some issues (concerned with distribution) are dealt with too early in the system life-cycle, while others (concerned with strategy) are hard-coded as programming-in-the-small issues, and still others (concerned with time) are hidden inside the operating system kernel. We present a reference architecture for monitoring and control systems that addresses the first two of these issues. The architecture raises distribution, activation and timing to an explicit, programming-in-the-large level.

As software systems become larger and more complex, a relevant part of code shifts from the application domain to the management of the system's run-time architecture (e.g., substituting components and connectors for run-time automated tuning). We propose a novel design approach for component based systems supporting architectural management in a systematic and conceptually clean way and allowing for the transparent addition of architectural management functionality to existing systems. The approach builds on the concept of reflection, extending it to the programming-in-the-large level, thus yielding architectural reflection (AR). The paper focuses on one aspect of AR, namely the monitoring and dynamic modification of the system's overall control structure (strategic reflection), which allows the behaviour of a system to be monitored and adjusted without modifying the system itself.

Realizing a shift of software engineering towards a component based approach to software development requires the development of higher level programming systems supporting the development of systems from components. The paper presents a novel approach to the design of large software systems where a program in the large describing the system's architecture is executed at run time to rule over the assembly and dynamic cooperation of components. This approach has several advantages following from a clean separation of concerns between programming in the small and programming in the large issues in instantiated systems.