Francesco Tisato

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.

On the complementary nature of event-driven and time-driven models

Abstract Event-driven and time-driven models exhibit a complementary nature, in the sense that they reflect the nature of the contrasting requirements that any real-time system must meet - i.e., performing actions “as soon as possible” or “at the right time”. Even if each of the models is sufficient to model a system, they should be intermixed to improve the expressiveness. This can be achieved by assuming one model as the primitive, and implementing the other on top of it. The paper introduces the rationale for choosing the time-driven model as the primitive, and discusses why this approach is possibly the most suitable for a wide range of control applications. In conclusion, a unifying model, based on the distinction between the atomic actions performed by reactive agents, the control performed by a time-driven control machine, and the planning performed by an event-driven planning machine, is introduced.

On the Duality Between Event-Driven and Time-Driven Models

Abstract The event-driven and time-driven models can be viewed as dual, in the sense that each of them can be sufficient to model a system. In real situations, however, they must co-exist to meet contrasting application requirements. The paper introduces a unifying model based on the separation among atomic actions performed by reactive agents, control performed by a timedriven control machine, and planning performed by an event-driven planning machine.

Components in an adaptive and QoS-based architecture

This paper aims to present the main software components we have developed in the context of the ARM (Adaptive Resource Management) project at University of Milano-Bicocca for an adaptive, distributed, service-oriented architecture. The goal of ARM is to manage the resources of a system in a way that enables it to dynamically identify and execute services on the available resources. Our approach chooses the most appropriate resource that is able to execute a service with the requested qualities of service (QoSs). To achieve adaptivity, ARM uses reflection at the architectural level. Exploiting the reflective representation of the systems resources and their related QoSs, ARM may organize them accordingly to various criteria and evaluate them based on their QoSs features and their potentiality in executing a requested service with the requested QoSs. To validate the ARM concepts, a prototype based on the peer-to-peer paradigm is currently under development. It aims to provide an adaptive support when using the resources available in our department.

Timing as a programming-in-the-large issue

Abstract HyperReal is an object-based programming paradigm which introduces a time-driven control model as a primitive mechanism. A system consists of a collection of actors which are not aware of timing issues. Timing is specified at a programming-in-the-large level, thus improving modularity and re-usability. The paper discusses the rationale for this approach; introduces HR2, an Oberon-based subset of HyperReal; and presents a set of examples which highlight how HR2 can be used for supporting different control disciplines.

Architectural abstractions and time modelling in HyperReal

This paper describes the foundation of the HyperReal project. It is centred on the definition of architectural abstractions that permit designing modular RT systems. Basic components are reactive agents manipulating data and connectors supporting interactions among agents. Such components are not aware of the system configuration nor of the control strategy, which are managed by a configurator and by a controller respectively. The controller relies on a time-driven model of control, and separates the definition of plans from the dispatching of the actions they define. Plans are associated with virtual clocks which support the explicit management of time. The architectural abstractions allow a designer to fully control the temporal behaviour of the system and to reuse components under different application-oriented control models.

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.

Attentive Monitoring of Multiple Video Streams Driven by a Bayesian Foraging Strategy

In this paper, we shall consider the problem of deploying attention to the subsets of the video streams for collating the most relevant data and information of interest related to a given task. We formalize this monitoring problem as a foraging problem. We propose a probabilistic framework to model observers attentive behavior as the behavior of a forager. The forager, moment to moment, focuses its attention on the most informative stream/camera, detects interesting objects or activities, or switches to a more profitable stream. The approach proposed here is suitable to be exploited for multistream video summarization. Meanwhile, it can serve as a preliminary step for more sophisticated video surveillance, e.g., activity and behavior analysis. Experimental results achieved on the UCR Videoweb Activities Data Set, a publicly available data set, are presented to illustrate the utility of the proposed technique.

Engineering spatial concepts

The success of a software system strongly depends on the ability of turning a precise domain analysis into a concrete architecture. Even if the domain model relies on sound ontological bases, there is often a wide semantic gap between the conceptual model and the concrete components that should reify it. To fill the semantic gap, relevant domain concepts should be engineered by identifying the corresponding architectural abstractions, which can be realized by concrete software components. Space plays a crucial role in many application domains, but surprisingly, related architectural abstractions have not emerged yet. This paper proposes space-related abstractions derived from the application of classical software engineering principles; in particular, the information hiding principle that leads to an operational definition of space. Basic abstractions are refined to deal with architectural aspects. As the underlying software engineering principles are close to principles that underlie the definition of space ontologies, the conjecture is that the proposed space architectural abstractions might be the basis for a formalization in ontological terms.