Computational Reflection

I am actively working on computational reflection, and in its application to software engineering, distribution, security and compiler design.

I have been involved in most of the recent events related to reflection: Reflection 2001, WERS'01, EWRMA'00, OORaSE99.

In the sequel of the page I will describe in detail the projects currently under development.

Reflective Middleware

The main objective of RMI- and object-based middleware is to provide a convenient environment for the realization of distributed computations. In most cases, unfortunately, interaction policies in these middleware platforms are hardwired into the platform itself.
In this way, distributed algorithms must be exclusively embedded in the application code, breaking any separation of concerns between functional and nonfunctional code.
We can summarize these kinds of problems with current middleware platforms as follows:

interaction policies are hidden from the programmer who cannot customize them (lack of adaptability)
communication, synchronization, and tuning code is intertwined with application code (lack of separation of concerns);
algorithms are scattered among several objects, thus forcing the programmer to explicitly coordinate their work (lack of global view).

A reflective approach can be considered as the glue to join together distributed and object-based programming and to fill gaps in their integration. Reflection provides a programming environment that exposes the implementation details of a system and allows the programmer to manipulate it. Moreover, a reflective approach permits one to easily separate interaction management from application code.
To address the above problems we have designed from scratch a novel reflective approach, called multi-channel reification model, that reifies and reflects directly on communications. This is a reflective model whose domain is not base-objects but rather communication among base-objects. This model has been realized by mChaRM, a reflective middleware written in Java. mChaRM is able to dynamically reify and modify multicast RMI with a minimal loss of performance with respect standard Java RMI.

Key Words: Reflection, Distributed Middleware, Reflective Middleware, Multicast Communication.

Collaboration:
Tokyo Institute of Technology, Prof. Shigeru Chiba.

Selected Publications

W. Cazzola. Communication-Oriented Reflection: a Way to Open Up the RMI Mechanism. PhD thesis, Università degli Studi di Milano, Milano, Italy, February 2001.
W. Cazzola. mChaRM: Reflective Middleware with a Global View of Communications. IEEE Distributed System On-Line, 3(2), Feb. 2002.
W. Cazzola, M. Ancona, F. Canepa, M. Mancini and Vanja Siccardi. Enhancing Java to Support Object Groups. In Proceedings of Recent Object-Oriented Trends (ROOTS'02). Bergen Norway. April 2002.

Developed Software

mChaRM: Home Page
Java Multicast RMI: Package

Security and Reflection

The main objective of this application of reflection consists of separating the security aspect from the rest of a system. Such an idea is based on the fact that the security is a non-functional feature with respect to the application behavior. The advantages due to such a separation are:

an improvement of the reusability of the security module,
the possibility of employee a specialized team in the development and in the implementation of the security module,
an improvement of the stability and correctness of the security module, and
an improvement of the readability and the maintainability of the security module code.

Computational reflection thanks to its properties (separation of concerns, transparency, and layerization) is the perfect glue to integrate a security module into an existing application.

At the moment we studied several different reflective approaches to security, and prototyped some different authorization policies with our reflective model (mChaRM).

Key Words: Reflection, Security, Authorization Policy.

Collaboration:
Florida Atlantic University, Prof. Eduardo B. Fernandez.

Selected Publications

M. Ancona, W. Cazzola and E.B. Fernandez. Reflective Authorization Systems: Possibilities, Benefits and Drawbacks. In Jan Vitek and Christian Jensen, editors, Secure Internet Programming: Security Issues for Distributed and Mobile Objects, LNCS 1606. Springer-Verlag, 1999.
M. Ancona, W. Cazzola, and E.B. Fernandez. A History-Dependent Access Control Mechanism Using Reflection. In proceedings of 5th ECOOP Workshop on Mobile Object Systems (EWMOS'99), Lisbon, Portugal, June 1999.

Developed Software

At the moment, the authorization policies we have developed are part of the mChaRM project and distributed with it. However, you can download our first attempt of using reflection to separate them from the functional aspect of the application from this web-page.

Architectural Reflection

We have developed a new type of reflection whose domain is no more the computation but rather its high-level description. Architectural reflection is thought to allow in a simple way dynamic reconfiguration of computational system. The idea is to use at run-time the software architecture of the system, and by modifying the architecture dynamically, it is possible to reconfigure the entire system. Passing through the software architecture grants the validity and the soundness of each modification.

Key Words: Reflection, Software Architecture, Dynamic Reconfiguration.

Collaborations:
Università di Milano Bicocca, Prof. Francesco Tisato.
Department of Computer Science, University College London, Dr. Andrea Savigni.

Selected Publications

W. Cazzola, A. Savigni, A. Sosio, and F. Tisato. Architectural Reflection: Bridging the Gap Between a Running System and its Architectural Specification. In proceedings of 6th Reengineering Forum (REF'98), Firenze, Italia, March 1998. IEEE.
W. Cazzola, A. Savigni, A. Sosio, and F. Tisato. Rule-Based Strategic Reflection: Observing and Modifying Behavior at the Architectural Level. In proceedings of 14th IEEE International Conference on Automated Software Engineering (ASE'99), Cocoa Beach, Florida, USA, October 1999.
W. Cazzola, A. Savigni, A. Sosio, and F. Tisato. Architectural Reflection. Realising Software Architectures via Reflective Activities. In Wolfang Emmerich and Stephan Tai, editors, Proceedings of EDO 2000, Lecture Notes in Computer Science 1999, pages 102-115. Springer-Verlag. Davis, USA, November 2000.

Analysis of Reflective Systems

The main objective consists of designing a methodology which applies to the standard object-oriented development approach (e.g., UML) some concepts from the reflection area, as the separation of concerns. This approach to the software development will allow to model reflective systems, separating functional from nonfunctional aspect and improving reuse and design quality as well as to design standard object-oriented systems.

Key Words: Reflection, Software Engineering, UML.

Collaborations:
Università di Milano Bicocca, Prof. Francesco Tisato.
Otto-von-Guericke-Universität Magdeburg, Prof. Gunter Saake and Dr. Ahmed Ghoneim.

Selected Publications

W. Cazzola, A. Ghoneim and G. Saake. Reflective Analysis and Design for Adapting Object Run-Time Behavior. In Proceedings of 8th International Conference on Object-Oriented Information Systems (OOIS'02). Lecture Notes in Computer Science. Montpellier, France. September 2002.
W. Cazzola, A. Sosio and F. Tisato. Shifting Up Reflection from the Implementation to the Analysis Level. In Reflection and Software Engineering, Lecture Notes in Computer Science 1826. Springer-Verlag, 2000.
W. Cazzola, A. Sosio, and F. Tisato. Reflection and Object-Oriented Analysis. In Proceedings of 1st OOPSLA Workshop on Reflection and Software Engineering (OORaSE'99), Denver, Colorado, USA, November 1999, pages 95-106.

Reflective Paradigm and Compilers

Reflection has been around for several year and many researchers have pointed out its potential and promises. However, its has never penetrated the programming realm at a level that we consider adequate for its capabilities. In our opinion, this is due to the absence of a characterization of the real essence of reflection that may lead to a very simple (i.e., minimal) and orthogonal (i.e., independent of the programming language) implementation.
Reflective programming paradigm covers a programming abstraction which is not considered by other paradigms, like the functional, the procedural, the logic, and the object-oriented one. It aggregates unrelated behaviors to achieve a composite component playing the behavior represented by the composition of the basic behaviors. Such a composition is performed through the causality relation existing among software components of a system.
The basic idea consists of shifting up reflective concepts from the programming to system level: a) reflection has a minimal impact on the programming language clauses. b) changes needed to support reflection are moved in the compiler's back-end. To validate our ideas, we developed from scratch a simple programming system, named Io, which embeds reflection from its early design stage.

Key Words: Reflection, Programming Language, Programming Paradigm, Compiler Design.

Selected Publications

M. Ancona and W. Cazzola. The Programming Language Io. Technical Report DISI-TR-04-02, DISI, Università degli Studi di Genova, May 2002.

All the cited paper and many others about these and past projects can be download from my bibliography page.