A number of approaches have been proposed to achieve separation of concerns. Although all these approaches form suitable candidates for separating cross-cutting concerns in a system, one approach can be more suitable for implementing certain types of concerns as compared to the others. This paper proposes a hybrid approach to separation of concerns. The approach is based on using the most suitable approach for implementing each cross-cutting concern in a system. The discussion is based on using three different approaches: composition filters, adaptive programming and aspect-oriented programming to implement cross-cutting concerns in SADES, a customisable and extensible object database evolution system.

Previous taxonomies of software evolution have focused on the purpose of the change (i.e., the why) rather than the underlying mechanisms. This paper proposes a taxonomy of software evolution based on the characterizing mechanisms of change and the factors that influence these mechanisms. The taxonomy is organized into the following logical groupings: temporal properties, objects of change, system properties, and change support. The ultimate goal

Over the recent years aspect-oriented programming (AOP) has found increasing interest among researchers in software engineering. Aspects are abstractions which capture and localise cross-cutting concerns. Although persistence has been considered as an aspect of a system aspects in the persistence domain in general and in databases in particular have been largely ignored. This paper brings the notion of aspects to object-oriented databases.

This paper describes a composite evolution approach which integrates the evolution of the various types of entities in an object-oriented database into one model. The approach provides maintainers with a coherent and comprehensible view of the system and at the same time maintains change histories at a fine granularity. Links among meta-objects are implemented using dynamic relationships which are semantic constructs and firstclass objects. Referential integrity is maintained by the relationships architecture reducing the evolution complexity at the meta-object level. A customisable and exchangeable instance adaptation approach is proposed. The approach is based on separating the instance adaptation code from class versions using aspects, abstractions used in Aspect-Oriented Programming to localise crosscutting concerns. A high level objectoriented model offering transparent access to the proposed evolution functionality is provided.

This paper discusses two mechanisms for weaving aspects in persistent environments founded on object-oriented databases. The first mechanism is based on exploiting existing aspect languages and their associated weavers while the second mechanism is based on building weaving functionality into the database management system (DBMS). The first mechanism has been used to integrate AspectJ and its associated weaver with the Jasmine ODBMS. The second approach has been used to implement a weaver within the SADES object database evolution system.

Persistent objects in an object database need to be adapted, either by physical conversion or wrapping, when the schema is changed to fix bugs or meet new requirements. Object database schema evolution introduces a number of concerns into the system, such as adaptation rules, the choice between conversion or wrapping, and backward compatibility. Our research aims to allow strategies for addressing such concerns to be dynamically replaced or altered for an existing, running database. An early prototype evolution framework has been developed as an interpreter for a custom object-oriented language, written in AspectJ. This position paper discusses some areas where aspects have been used to separate concerns, and suggests other concerns in the framework which are likely to benefit from an aspect-oriented approach. The concerns discussed include: selective lazy evaluation, contracts, metacrosscutting, and the maintenance of custom version-specific extents.

approach based on separation of concerns. The lack of customisability and extensibility in existing evolution frameworks is a consequence of using attributes at the meta-object level to implement links among meta-objects and the injection of instance adaptation code directly into the class versions. The proposed approach uses dynamic relationships to separate the connection code from meta-objects and aspects - abstractions used by Aspect-Oriented Programming to localise cross-cutting concerns - to separate the instance adaptation code from class versions. The result is a customisable and extensible evolution framework with low maintenance overhead.

Code repositories play a central role in the reuse and mining of existing assets when engineering large, complex software systems. It is, therefore, essential that database support be extended to new programming paradigms as and when they emerge. This paper proposes an approach to support the storage, reuse and mining of aspects - constructs used in AspectOriented Programming (AOP) to separate crosscutting concerns - in AspectJ (an aspect language for Java) using a relational database. The approach is based on mapping an aspect's anatomy to the relational model hence allowing finegrained queries to be composed. This results in greater flexibility during search and retrieval in contrast with most existing code repositories which store the code as BLObs complemented by meta-data about the code.

N-Version Mode expose a range of abstract methods that are concretised by the sub-aspects to customise the schema evolution approach.

Abstract. Object database management systems (ODBMSs) typically offer fixed approaches to evolve the schema of the database and adapt existing instances accordingly. Applications, however, have very specialised evolution requirements that can often not be met by the fixed approach offered by the ODBMS. In this paper, we discuss how aspect-oriented programming (AOP) has been employed in the AspOEv evolution framework, which supports flexible adaptation and introduction of evolution mechanisms – for dynamic evolution of the schema and adaptation of existing instances – governing an object database. We argue that aspects support flexibility in the framework by capturing crosscutting hot spots (customisation points in the framework) and establishing their causality relationships with the custom evolution approaches. Furthermore, aspects help in information hiding by screening the database programmer from the complexity of the hot spots manipulated by custom evolution mechanisms. They also make it possible to preserve architectural constraints and specify custom version polymorphism policies. 1.