Walter Cazzola

On the Maintainability of Aspect-Oriented Software: A Concern-Oriented Measurement Framework

Aspect-oriented design needs to be systematically assessed with respect to modularity flaws caused by the realization of driving system concerns, such as tangling, scattering, and excessive concern dependencies. As a result, innovative concern metrics have been defined to support quantitative analyses of concerns properties. However, the vast majority of these measures have not yet being theoretically validated and managed to get accepted in the academic or industrial settings. The core reason for this problem is the fact that they have not been built by using a clearly-defined terminology and criteria. This paper defines a concern-oriented framework that supports the instantiation and comparison of concern measures. The framework subsumes the definition of a core terminology and criteria in order to lay down a rigorous process to foster the definition of meaningful and well-founded concern measures. In order to evaluate the framework generality, we demonstrate the framework instantiation and extension to a number of concern measures suites previously used in empirical studies of aspect-oriented software maintenance.

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.

Reflection and software engineering

Reflection and Software Engineering Foundations.- Shifting Up Reflection from the Implementation to the Analysis Level.- Towards a True Reflective Modeling Scheme.- Reflective Software Adaptability and Evolution.- Declarable Modifiers: A Proposal to Increase the Efficacy of Metaclasses.- Managing Evolution Using Cooperative Designs and a Reflective Architecture.- Reflective Middleware.- The Role of Reflective Middleware in Supporting the Engineering of Dynamic Applications.- Active Network Service Management Based on Meta-level Architectures.- Engineering Java-Based Reflective Languages.- OpenJava: A Class-Based Macro System for Java.- OpenJIT Frontend System: An Implementation of the Reflective JIT Compiler Frontend.- Kava - A Reflective Java Based on Bytecode Rewriting.- Dynamic Reconguration through Reflection.- Using Reflection to Support Dynamic Adaptation of System Software: A Case Study Driven Evaluation.- On the Integration of Configuration and Meta-level Programming Approaches.- Carp@ - A Reflection Based Tool for Observing Jini Services.

Evaluation of Object-Oriented Reflective Models

Reflection is a suitable paradigm for developing open systems. Reflection improves software reusability and stability, reducing development costs. But with several different kinds of reflection to choose from, it is important to know which reflective model to use and when.

WIDGET-TEMP: A Novel Web-Based Approach for Thermoeconomic Analysis and Optimization of Conventional and Innovative Cycles

In a deregulated energy market the adoption of multipurpose and flexible software tools for the optimal design and sizing of energy systems is becoming mandatory. For these reasons, we have developed WIDGET-TEMP (Web-based Interface and Distributed Graphical Environment for TEMP, ThermoEconomic Modular Program), a tool which is the result of an interdisciplinary research which applied recent IT innovations such as XML and web-based approaches to the analysis and optimization of energy plant layouts on a thermoeconomic basis. WIDGET provides an interface for remotely accessing the internal thermoeconomic analysis, the full life-cycle cost and investment assessment, which includes the economic impact of environmental costs due to pollutant emissions. This approach reduces the requirements for the local machine in terms of processor time and memory, and allows users to exploit the tool just when needed. An initial functional productive diagram of the plant is now automatically drawn and is available to the user on a visual basis. We present a general description of the tool organization and outline the approach for modeling the technical performance and cost of the component. Then, we describe the latest upgrades of TEMP, and report the new gas turbine cost equations. Finally, the tool is applied to a conventional simple and combined cycle, showing both the usability of the new tool and the reliability of the results.

JavAdaptor-Flexible runtime updates of Java applications

Software is changed frequently during its life cycle. New requirements come, and bugs must be fixed. To update an application, it usually must be stopped, patched, and restarted. This causes time periods of unavailability, which is always a problem for highly available applications. Even for the development of complex applications, restarts to test new program parts can be time consuming and annoying. Thus, we aim at dynamic software updates to update programs at runtime. There is a large body of research on dynamic software updates, but so far, existing approaches have shortcomings either in terms of flexibility or performance. In addition, some of them depend on specific runtime environments and dictate the programs architecture. We present JavAdaptor, the first runtime update approach based on Java that (a) offers flexible dynamic software updates, (b) is platform independent, (c) introduces only minimal performance overhead, and (d) does not dictate the program architecture. JavAdaptor combines schema changing class replacements by class renaming and caller updates with Java HotSwap using containers and proxies. It runs on top of all major standard Java virtual machines. We evaluate our approachs applicability and performance in non‐trivial case studies and compare it with existing dynamic software update approaches. Copyright

Software Evolution through Dynamic Adaptation of Its OO Design

In this paper we present a proposal for safely evolving a software system against run-time changes. This proposal is based on a reflective architecture which provides objects with the ability of dynamically changing their behavior by using their design information. The meta-level system of the proposed architecture supervises the evolution of the software system to be adapted that runs as the base-level system of the reflective architecture. The meta-level system is composed of cooperating components; these components carry out the evolution against sudden and unexpected environmental changes on a reification of the design information (e.g., object models, scenarios and statecharts) of the system to be adapted. The evolution takes place in two steps: first a meta-object, called evolutionary meta-object, plans a possible evolution against the detected event then another meta-object, called consistency checker meta-object validates the feasibility of the proposed plan before really evolving the system. Meta-objects use the system design information to govern the evolution of the base-level system. Moreover, we show our architecture at work on a case study.

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.

Domain-Specific languages in few steps: the neverlang approach

Often an ad hoc programming language integrating features from different programming languages and paradigms represents the best choice to express a concise and clean solution to a problem. But, developing a programming language is not an easy task and this often discourages from developing your problem-oriented or domain-specific language. To foster DSL development and to favor clean and concise problem-oriented solutions we developed Neverlang The Neverlang framework provides a mechanism to build custom programming languages up from features coming from different languages. The composability and flexibility provided by Neverlang permit to develop a new programming language by simply composing features from previously developed languages and reusing the corresponding support code (parsers, code generators, …). In this work, we explore the Neverlang framework and try out its benefits in a case study that merges functional programming a la Python with coordination for distributed programming as in Linda.

Neverlang 2 – Componentised Language Development for the JVM

Traditional compiler development is non-modular. Although syntax extension and DSL embedding is making its way back in modern language design and implementation, componentisation in compiler construction is still an overlooked matter. Neverlang is a language development framework that emphasises modularity and code reuse. Neverlang makes extension, restriction and feature sharing easier, by letting developers define language components in distinct, independent units, that can be compiled independently and shared across different language implementations, even in their compiled form. The semantics of the implemented languages can be specified using any JVM-supported language. In this paper we will present the architecture and implementation of Neverlang 2, by the help of an example inspired by mobile devices and context-dependent behaviour. The Neverlang framework is already being employed successfully in real-world environments.