AspectJ Research Papers - Academia.edu (original) (raw)

Modularity is the single attribute of software that allows a program to be intellectually manageable [29]. The recipe for modularizing is to define a narrow interface, hide an implementation detail, keep low coupling and high cohesion.... more

Modularity is the single attribute of software that allows a program to be intellectually manageable [29]. The recipe for modularizing is to define a narrow interface, hide an implementation detail, keep low coupling and high cohesion. Over a decade ago, aspect-oriented programming (AOP) was proposed in the literature to "modularize the un-modularizable" [24]. Since then, aspect-oriented languages have been providing new abstraction and composition mechanisms to deal with concerns that could not be modularized because of the limited abstractions of the underlying programming language. This paper is a continuation of our earlier work [32] and further investigates AO software with regard to coupling and cohesion. We compare two versions (Java and AspectJ) of ten applications to review AOP within the context of software modularity. It turns out that the claim that "the software built in AOP is more modular than the software built in OOP" is a myth.

Every new programming technique makes claims that software engineers want to hear. Such is the case with aspect-oriented programming (AOP). This paper describes a quasi-controlled experiment which compares the evolution of two... more

Every new programming technique makes claims that software engineers want to hear. Such is the case with aspect-oriented programming (AOP). This paper describes a quasi-controlled experiment which compares the evolution of two functionally equivalent programs, developed in two different paradigms. The aim of the study is to explore the claims that software developed with aspect-oriented languages is easier to maintain and reuse than this developed with object-oriented languages. We have found no evidence to support these claims.

Dynamic analysis of software is a trending technique nowadays as it covers the run time features like dynamic binding, polymorphism, multi-threading, etc., compared to static analysis. Many methods exist in literature to perform dynamic... more

Dynamic analysis of software is a trending technique nowadays as it covers the run time features like dynamic binding, polymorphism, multi-threading, etc., compared to static analysis. Many methods exist in literature to perform dynamic software analysis, and aspect-oriented programming (AOP) has a clear edge over other approaches. It is much more straightforward and easy to design. From the literature study, it is explicit that most of the researchers worked on dynamic coupling metrics and gave little emphasis on object-oriented features like cohesion, complexity, and polymorphism. Therefore, in this paper, a new set of dynamic metrics covering cohesion, complexity, and polymorphism features is proposed. For evaluating these metrics, a dynamic analyzer tool, AspectJ, i.e., an eclipse plugin, is used, and aspects were developed using AOP on the eclipse platform. The proposed tool was devised mainly for Java classes. Furthermore, the empirical validation of proposed metrics is based on a case study and experimental study using a fuzzy logic-based predictive maintainability model. Lastly, the authors concluded that proposed dynamic metrics better predict software quality in terms of maintainability than static metrics.

The so-called passive' participle in NENA dialects is said to function as both passive and active. This apory is resolved once it is shown that it is neither one or the other, namely that the opposition is not diathetic to begin with but... more

The so-called passive' participle in NENA dialects is said to function as both passive and active. This apory is resolved once it is shown that it is neither one or the other, namely that the opposition is not diathetic to begin with but aspectual. Tha so-called passive participle is perfect(ive) and the so-called active one is imperfect(ive). Transitivity, or rather valency, is narrowly linked to that, and in this language so are ergativity and case.

Abstract: Implementing crosscutting concerns for transactions is difficult, even using aspect-oriented programming languages such as AspectJ. Many of these challenges arise because the context of a transaction-related crosscutting concern... more

Abstract: Implementing crosscutting concerns for transactions is difficult, even using aspect-oriented programming languages such
as AspectJ. Many of these challenges arise because the context of a transaction-related crosscutting concern consists of
loosely-coupled abstractions like dynamically-generated identifiers, timestamps, and tentative value sets of distributed resources.
Current aspect-oriented programming languages do not provide joinpoints and pointcuts for weaving advice into high-level
abstractions or contexts, like transaction contexts. To address these problems, we propose an extension to AspectJ framework, called
TransJ, that allows developers to define pointcuts in terms of transaction abstractions and that automatically keeps track of context
information for transactions. This paper describes TransJ as an abstract independent framework for weaving crosscutting concerns
into high-level runtime abstractions, with which developers can implement transaction-related crosscutting concerns in modular,
cohesive and loosely coupled transaction-aware aspects. Finally, this paper presents eight different ways in which TransJ can
improve the reuse with preserving the performance of applications requiring transactions. Informally, these hypotheses are that
TransJ yields (1) better encapsulation and separation of concern; (2) looser coupling and less scattering; (3) higher cohesion and less
tangling; (4) reduces complexity; (5) improves obliviousness; (6) preserves efficiency; (7) improves extensibility; and (8) hastens the
productivity. A brief discussion of experiment to test the hypotheses is provided, but the details of the experiment are left for another
paper.

Over a decade ago, aspect-oriented programming (AOP) was proposed to “modularize the un-modularizable”. Nowadays, the aspect-oriented paradigm pervades all areas of software engineering. With its growing popularity, practitioners are... more

Over a decade ago, aspect-oriented programming (AOP) was proposed to “modularize the un-modularizable”. Nowadays, the aspect-oriented paradigm pervades all areas of software engineering. With its growing popularity, practitioners are beginning to wonder whether they should start looking into it. However, every new paradigm makes claims that managers want to hear. The aim of this PhD dissertation is to find out how much of what has been written about AOP is true and how much is hype.

Aspect-oriented programming (AOP) emerged as a paradigm to modularize the concerns that lead to interwoven code if implemented using traditional programming techniques. Unfortunately, the new constructs introduced by aspect-oriented (AO)... more

Aspect-oriented programming (AOP) emerged as a paradigm to modularize the concerns that lead to interwoven code if implemented using traditional programming techniques. Unfortunately, the new constructs introduced by aspect-oriented (AO) languages result in both: (1) obstacles in modular reasoning; and (2) high coupling between aspects and the augmented modules. There have been numerous attempts to tackle these issues, but none have succeeded without sacrificing obliviousness or losing the power of AOP. In this paper, we propose a new approach to AOP inspired by the classification of aspects by Clifton & Leavens. Our approach reduces coupling in AO programs and restores modular reasoning in case when the aspects are spectators.

This paper proposes Zás, a novel, flexible, and expressive authorization mechanism for Java. Zás has been inspired by Ramnivas Laddad's proposal to modularize Java Authentication and Authorization Services (JAAS) using an Aspect-Oriented... more

This paper proposes Zás, a novel, flexible, and expressive authorization mechanism for Java. Zás has been inspired by Ramnivas Laddad's proposal to modularize Java Authentication and Authorization Services (JAAS) using an Aspect-Oriented Programming (AOP) approach. Zás' aims are to be simultaneously very expressive, reusable, and easy to use and configure. Zás allows authorization services to be non-invasively added to existing code. It also cohabits with a wide range of authentication mechanisms. Zás uses Java 5 annotations to specify permission requirements to access controlled resources. These requirements may be changed directly during execution. They may also be calculated by client supplied permission classes before each access to the corresponding resource. These features, together with several mechanisms for permission propagation, expression of trust relationships, depth of access control, etc., make Zás, we believe, an interesting starting point for further research on the use of AOP for authorization.

An object invariant consisting of a set of properties that must hold for all instances of a class at any time is usually used in object-oriented design. However, verifying object invariants at runtime is always a challenging task in... more

An object invariant consisting of a set of properties that must hold for all instances of a class at any time is usually used in object-oriented design. However, verifying object invariants at runtime is always a challenging task in software verification. This paper proposes a method for verifying invariants of Java objects at runtime using AOP. Suppose that a software application is designed using UML models and its constraints are specified in OCL expressions, the software is then implemented, by default, using the UML design. They propose to construct verifiable aspects which are automatically generated from OCL constraints. These aspects can be woven into Java code to check whether object invariants are violated at runtime. Benefiting from AOP in separation of crosscutting concerns and weaving mechanisms, generated aspects can do the verification task whenever values of objects' attributes are changed. A Verification Aspect Generator (VAG) tool has been developed allowing th...

Aspect-oriented programming (AOP) promises to benefit software engineering by providing a layer of abstraction that can modularize system-level concerns. AOP is still a very young area of research and has yet to receive mainstream... more

Aspect-oriented programming (AOP) promises to benefit software engineering by providing a layer of abstraction that can modularize system-level concerns. AOP is still a very young area of research and has yet to receive mainstream acceptance in industry. As a result, the industry as a whole lacks experience and knowledge concerning long term maintenance issues with AOP in deployed commercial applications. Fault models that result from software maintenance in aspect-oriented software development (AOSD) are not nearly as well understood as they are for object-oriented software development (OOSD). This paper will explore some of the long-term maintenance issues that can occur with AspectJ, which is an implementation of AOP for the Java programming language. More specifically, the ability of AspectJ (as of version 1.2) to weave into existing bytecode that already contains woven aspects can create unexpected and potentially unsolvable problems. This will hopefully lead to further discuss...

Dynamic analysis of software is a trending technique nowadays as it covers the run time features like dynamic binding, polymorphism, multi-threading, etc., compared to static analysis. Many methods exist in literature to perform dynamic... more

Dynamic analysis of software is a trending technique nowadays as it covers the run time features like dynamic binding, polymorphism, multi-threading, etc., compared to static analysis. Many methods exist in literature to perform dynamic software analysis, and aspect-oriented programming (AOP) has a clear edge over other approaches. It is much more straightforward and easy to design. From the literature study, it is explicit that most of the researchers worked on dynamic coupling metrics and gave little emphasis on object-oriented features like cohesion, complexity, and polymorphism. Therefore, in this paper, a new set of dynamic metrics covering cohesion, complexity, and polymorphism features is proposed. For evaluating these metrics, a dynamic analyzer tool, AspectJ, i.e., an eclipse plugin, is used, and aspects were developed using AOP on the eclipse platform. The proposed tool was devised mainly for Java classes. Furthermore, the empirical validation of proposed metrics is based on a case study and experimental study using a fuzzy logic-based predictive maintainability model. Lastly, the authors concluded that proposed dynamic metrics better predict software quality in terms of maintainability than static metric.