Andrea Savigni

Architectural Reflection: Realising Software Architectures via Reflective Activities

Architectural reflection is the computation performed by a software system about its own software architecture. Building on previous research and on practical experience in industrial projects, in this paper we expand the approach and show a practical (albeit very simple) example ofa pplication of architectural reflection. The example shows how one can express, thanks to reflection, both functional and nonfunctional requirements in terms ofob ject-oriented concepts, and how a clean separation ofcon cerns between application domain level and architectural level activities can be enforced.

Rule-based strategic reflection: observing and modifying behaviour at the architectural level

As software systems become larger and more complex, a relevant part of code shifts from the application domain to the management of the systems 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 systems overall control structure (strategic reflection), which allows the behaviour of a system to be monitored and adjusted without modifying the system itself.

A fresh look at programming-in-the-large

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 systems 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.

Real-time programming-in-the-large. The case of monitoring and control systems

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.

A software architecture for real-time, embedded monitoring systems

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.

ESCORT: lessons from an integration project

We present the key lessons learned from the ESCORT European project. ESCORT is concerned with integrating diverse applications and devices for traffic control at the intersection level. The paper emphasises the difficulty of breaking existing, vertical products to build an integration platform, and the role of object technology (and UML in particular) in this context.