Orthogonal Persistence and AOP: a Balancing Act
Mohammed Al-Mansari, Stefan Hanenberg, Rainer Unland
Institute for Computer Science and Business Information Systems (ICB) University of Duisburg-Essen, Germany

{ Mohammed.Al-Mansari, Stefan.Hanenberg, Rainer.Unland }@icb.uni-due.de ABSTRACT
In order to increase the productivity of the application developers, it is desirable to remove thepersistence concern from their responsibility. For this purpose, the orthogonal persistence concept was introduced along with three principles: type orthogonality, persistence independence and transitivity. From an aspect-oriented point of view these principles have to be considered from the perspective of obliviousness. There is already a number of aspect-oriented persistence solutions where it isnot that clear whether they handle the previous principles really in an oblivious way. In this paper, we discuss to what extent these aspect-oriented solutions really make the developer oblivious of the persistence concern. As a conclusion, we find that these systems in general defeat the orthogonal persistence and consequently, using them distracts developers from concentrating on the applicationlogic. In order to increase the obliviousness of the persistence concern we propose a combination of two new concepts: persisting containers and path expression pointcuts. [12]), the obliviousness characteristic [14] is synonymous to the term orthogonality. Applying it to the domain of persistence implies that the application code does not have to be prepared in order to introduce persistence.Until now, the aspect-oriented community has made a significant effort to apply AOP in providing orthogonal object persistence (see e.g. [25, 27, 28]). Accordingly, it is crucial to assess whether these proposals comply with the principle of orthogonal persistence, i.e. whether they do not require to prepare code in order to make objects persistent. This paper critically discusses the extent to whichcurrent AO persistence proposals meet orthogonal persistence. Thereto, we distinguish between different levels of code (depending on the role the code plays for persistence) and also consider conventional solutions such as EJB and JDO. Based on this characterization we see that current AO solutions provide a better localization of the persistence concern, however, they do not comply completelywith the orthogonal persistence principle. This paper goes a step further in providing a better level of obliviousness to the object persistence. In order to achieve this goal, we propose a combination of the two new concepts: persisting containers and path expression pointcuts [1]. We will show how this proposal solves the problem of breaking the orthogonal persistence principle resulting fromcurrent AO solutions. We insist that achieving full obliviousness for the persistence concern is not possible especially for complex systems like [19, 20]. However, the paper discusses how our proposal can be used to address some aspects that are considered in [20]. It should be noted that this paper neither considers all persistence issues nor does it provide a complete persistence framework. Rather,it analyzes the shortcoming of the current AO persistence solutions and gives a first step into the direction of providing an even more oblivious implementation of the persistence concern. The paper is organized as follows: Section 2 motivates the need for (still) discussing persistence from the aspect-oriented perspective. In Section 3 we describe our proposal: the combination of persistingcontainers and path expression pointcuts that addresses the problem. Section 4 discusses some related work. In Section 5 we discuss some issues of our proposal and the future work, then we conclude the paper.

Categories and Subject Descriptors
D.3.3 [Programming Languages]: Language Constructs and Features – Classes and objects, Dynamic storage management.

Keywords
Orthogonal persistence,…