AspectJ Language Research Articles

Performance Analysis of Qualitative Evaluation Model for Software Reuse with AspectJ using AHP

Reusability is necessary for developing advance software. Aspect Oriented programming is an emerging approach which understand the problem of arrangement of scattered software modules and tangled code. The aim of this paper is to explore the AOP approach with implementation of real life projects in AspectJ language and its impact on software quality in form of reusability. In this paper, experimental results are evaluated of 11 projects (Java and AspectJ) using proposed Quality Evaluation Model for Software Reuse (QEMSR) and existing Aspect Oriented Software Quality Model (AOSQ). To evaluate AOP quality model QEMSR based on developers AOP projects by using Analytic Hierarchy Process (AHP) tools. Paper provides the evaluation of software reusability and positive impact on software quality. QEMSR model is used to assess Aspect Oriented reusability quality issues, which helps developers to adapt for software development. The overall quality of three models QEMSR, existing AOSQ and PAOSQMO are 0.62552223, 0.5283693, and 0.505815 calculated. According to this, QEMSR model is best in form of quality in same characteristics and sub-characteristics.

Implementing design patterns as parametric aspects using ParaAJ: The case of the singleton, observer, and decorator design patterns

Implementation of a design pattern can take many forms according to the programming language being used. Most of the literature presents design patterns in their conventional object-oriented implementations. Several other studies show the implementation in aspect-oriented languages such as AspectJ, EOS, and Caesar. In this work, we compare the implementation of three design patterns: singleton, observer, and decorator design patterns in these languages and also discuss the possibility of implementing them in ParaAJ: an extension to the AspectJ language that implements the idea of parametric aspects. We found that ParaAJ helps in making the implementation of the singleton and observer patterns reusable but it fails to help in the decorator case. The problem with the decorator pattern exists because of the current translation mechanism of ParaAJ׳s aspects to normal AspectJ׳s aspects. This opens the door for further work in ParaAJ to better support the idea of parametric aspects.

Inference rules for generic code migration of aspect-oriented programs

Several changes occurred in the AspectJ language to provide support for parametric polymorphism. Such changes aim to improve the source code type safety and to prepare the language to support generic code migration. Current approaches for this kind of migration focus only on object-oriented code. Therefore, they do not consider the use of aspects to encapsulate crosscutting concerns. We propose a collection of type constraint rules for the polymorphic version of AspectJ. These rules are used together with an existing constraint based algorithm to enable the conversion of non-generic code to add actual type parameters in both Java and AspectJ languages.

Aspect-Oriented Race Detection in Java

In the past, researchers have developed specialized programs to aid programmers in detecting concurrent programming errors such as deadlocks, livelocks, starvation, and data races. In this work, we propose a language extension to the aspect-oriented programming language AspectJ, in the form of three new pointcuts, lock(), unlock(), and maybeShared(). These pointcuts allow programmers to monitor program events where locks are granted or handed back, and where values are accessed that may be shared among multiple Java threads. We decide thread locality using a static thread-local-objects analysis developed by others. Using the three new primitive pointcuts, researchers can directly implement efficient monitoring algorithms to detect concurrent-programming errors online. As an example, we describe a new algorithm which we call RACER, an adaption of the well-known ERASER algorithm to the memory model of Java. We implemented the new pointcuts as an extension to the AspectBench Compiler, implemented the RACER algorithm using this language extension, and then applied the algorithm to the NASA K9 Rover Executive and two smaller programs. Our experiments demonstrate that our implementation is effective in finding subtle data races. In the Rover Executive, RACER finds 12 data races, with no false warnings. Only one of these races was previously known.

Modeling and enforcing invariants of dynamic software architectures

In this paper, we propose an "end-to-end" approach that supports dynamic reconfiguration of software architectures taking advantage of graphical modeling, formal methods and aspect-oriented programming. There are three ingredients of the proposal. The specification end of the solution is covered by a new UML profile enabling to specify the desired architectural style (model), its invariants and the intended reconfiguration operations. In order to verify the consistency of the model and the preservation of the invariants after every reconfiguration, we automatically generate formal specifications in Z notation from the defined model. At the runtime enforcing end of the solution, we propose to encode the enforcement logic as aspect in the AspectJ language. The third important ingredient that makes our approach end-to-end is the automatic translation of formal specifications into aspect-based enforcement code.

Transactional pointcuts

Aspect-oriented mechanisms are characterized by their join point models. A join point model has three components: join points, which are elements of language semantics; "a means of identifying join points"; and "a means of affecting the behaviour at those join points." A pointcut-advice model is a dynamic join point model in which join points are points in program execution. Pointcuts select a set of join points, and advice affects the behaviour of the selected join points. In this model, join points are typically selected and advised independently of each other. That is, the relationships between join points are not taken into account in join point selection and advice. In practice, join points are often not independent. Instead, they form part of a higher-level operation that implements the intent of the developer ( e.g. managing a resource). There are natural situations in which join points should be selected only if they play a specific role in that operation. We propose a new join point model that takes join point interrelationships into account and allows the designation of more complex computations as join points. Based on the new model, we have designed an aspect-oriented construct called a transactional pointcut (transcut) . Transcuts select sets of interrelated join points and reify them into higher-level join points that can be advised. They share much of the machinery and intuition of pointcuts, and can be viewed as their natural extension. We have implemented a transcuts prototype as an extension to the AspectJ language and integrated it into the abc compiler. We present an example where a transcut is applied to implement recommended resource handling practices in the presence of exceptions within method boundaries.

On the modularization and reuse of exception handling with aspects

AbstractThis paper presents an in‐depth study of the adequacy of the AspectJ language for modularizing and reusing exception‐handling code. The study consisted of refactoring existing applications so that the code responsible for implementing error‐handling strategies was moved to newly created exception handler aspects. We have performed quantitative assessments of five systems—four object‐oriented and one aspect‐oriented—based on four key quality attributes, namely separation of concerns, coupling, cohesion, and conciseness. Our investigation also included a multi‐perspective analysis of the refactored systems, including (i) the extent to which error‐handling aspects can be reused, (ii) the beneficial and harmful aspectization scenarios for exception handling, and (iii) the scalability of AOP to support the modularization of exception handling in the presence of other aspects. Copyright © 2009 John Wiley & Sons, Ltd.

GenUTest: a unit test and mock aspect generation tool

Unit testing plays a major role in the software development process. What started as an ad hoc approach is becoming a common practice among developers. It enables the immediate detection of bugs introduced into a unit whenever code changes occur. Hence, unit tests provide a safety net of regression tests and validation tests which encourage developers to refactor existing code with greater confidence. One of the major corner stones of the agile development approach is unit testing. Agile methods require all software classes to have unit tests that can be executed by an automated unit-testing framework. However, not all software systems have unit tests. When changes to such software are needed, writing unit tests from scratch, which is hard and tedious, might not be cost effective. In this paper we propose a technique which automatically generates unit tests for software that does not have such tests. We have implemented GenUTest, a prototype tool which captures and logs interobject interactions occurring during the execution of Java programs, using the aspect-oriented language AspectJ. These interactions are used to generate JUnit tests. They also serve in generating mock aspects—mock object-like entities, which enable testing units in isolation. The generated JUnit tests and mock aspects are independent of the tool, and can be used by developers to perform unit tests on the software. Comprehensiveness of the unit tests depends on the software execution. We applied GenUTest to several open source projects such as NanoXML and JODE. We present the results, explain the limitations of the tool, and point out direction to future work to improve the code coverage provided by GenUTest and its scalability.

Using Aspect Programming to Secure Web Applications

As the Internet users increase, the need to protect web servers from malicious users has become a priority in many organizations and companies. Writing crosscutting functions in complex software should take advantage of the modularity offered by new software development approaches. With AspectOriented Programming (AOP), separating concerns when designing an application fosters reuse, parameterization and maintenance. In this paper, we design a security aspect called AProSec for detecting SQL injection and Cross Scripting Site (XSS), that are common attacks in web servers. We experimented this aspect with AspectJ language and JBoss AOP. By this experimentation, we show the advantage of runtime platforms such as JBoss AOP for changing security policies at runtime. Finally, we describe related work on security and AOP.

Declarative, formal, and extensible syntax definition for aspectJ

Aspect-Oriented Programming (AOP) is attracting attention from both research and industry, as illustrated by the ever-growing popularity of AspectJ, the de facto standard AOP extension of Java. From a compiler construction perspective AspectJ is interesting as it is a typical example of compositional language, ie a language composed of a number of separate languages with different syntactical styles: in addition to plain Java, AspectJ includes a language for defining pointcuts and one for defining advices. Language composition represents a non-trivial challenge for conventional parsing techniques. First, combining several languages with different lexical syntax leads to considerable complexity in the lexical states to processed. Second, as new language features for AOP are being explored, many research proposals are concerned with further extending the AspectJ language, resulting in a need for an extensible syntax definition.This paper shows how scannerless parsing elegantly addresses the issues encountered by conventional techniques when parsing AspectJ . We present the design of a modular, extensible, and formal definition of the lexical and context-free aspects of the AspectJ syntax in the Syntax Definition Formalism SDF, which is implemented by a scannerless, generalized-LR parser (SGLR). We introduce grammar mixins as a novel application of SDF's modularity features, which allows the declarative definition of different keyword policies and combination of extensions. We illustrate the modular extensibility of our definition with syntax extensions taken from current research on aspect languages. Finally, benchmarks show the reasonable performance of scannerless generalized-LR parsing for this grammar.

Applyinq AspectJ to J2EE application development

(AOP) programming is a technique that allows programmers to modularize crosscutting concerns (behavior that cuts across the typical divisions of responsibility, such as concurrency or security). Aspect-oriented programming and the AspectJ language can reduce code size and defects while increasing understandability. Video Monitoring Services of America (VMS) began to investigate the adoption of AOP into the development of Adbase, the Java 2 Enterprise Edition-based application. Adbase supplies a Web-based search and e-commerce interface on VMS's library of advertising data. It uses a wide range of J2EE technologies, both commercial and open source. The Adbase team varied from four to seven full-time developers during the time frame covered by this article. We followed a modified version of extreme programming with a focus on emergent design and adherence to XP practices such as programmer testing-and pair programming

Adding trace matching with free variables to AspectJ

An aspect observes the execution of a base program; when certain actions occur, the aspect runs some extra code of its own. In the AspectJ language, the observations that an aspect can make are confined to the current action: it is not possible to directly observe the history of a computation.Recently, there have been several interesting proposals for new history-based language features, most notably by Douence et al. and by Walker and Viggers. In this paper, we present a new history-based language feature called tracematches that enables the programmer to trigger the execution of extra code by specifying a regular pattern of events in a computation trace. We have fully designed and implemented tracematches as a seamless extension of AspectJ.A key innovation in our tracematch approach is the introduction of free variables in the matching patterns. This enhancement enables a whole new class of applications in which events can be matched not only by the event kind, but also by the values associated with the free variables. We provide several examples of applications enabled by this feature.After introducing and motivating the idea of tracematches via examples, we present a detailed semantics of our language design, and we derive an implementation from that semantics. The implementation has been realised as an extension of the abc compiler for AspectJ.

Aspectual Caml

We propose an aspect-oriented programming (AOP) language called Aspectual Caml based on a strongly-typed functional language Objective Caml with two AOP mechanisms similar to those in AspectJ language. This paper describes the design and implementation issues of those AOP mechanisms that give us insights into the interaction between AOP features and common features in strongly-typed functional languages such as type inference, polymorphic types and curried functions. We implemented a prototype compiler of the language and used the language for separating crosscutting concerns in application programs, including for separating descriptions of a type system from compiler descriptions.

Implementing protocols via declarative event patterns

This paper introduces declarative event patterns (DEPs) as a means to implement protocols while improving their traceability, comprehensibility, and maintainability. DEPs are descriptions of sequences of events in the execution of a system that include the ability to recognize properly nested event structures. DEPs allow a developer to describe a protocol at a high-level, without the need to express extraneous details. A developer can indicate that specific actions be taken when a given pattern occurs. DEPs are automatically translated into the appropriate instrumentation and automaton for recognizing a given pattern. Support for DEPs has been implemented in a proof-of-concept extension to the AspectJ language that is based on advanced compiler technology. A case study is described that compares the use of DEPs in the implementation of a protocol (FTP user authentication) to the use of a set of other approaches, both object-oriented and aspect-oriented.

Case study

This paper presents a simple three-tier client/server application using two prototypes. The first prototype makes the use of a traditional OOP language, Java. The second prototype uses the Aspect-Oriented Programming (AOP) language AspectJ. The advantages and disadvantages of developing a concurrent system using the AOP paradigm are evaluated, as well as the potential of the AOP paradigm.