Pluggable AOP: Designing Aspect Mechanisms for Third-party Composition

Studies of Aspect-Oriented Programming (AOP) usually focus on a language in which a specific aspect extension is integrated with a base language. Languages specified in this manner have a fixed, non-extensible AOP functionality. In this paper we consider the more general case of integrating a base language with a set of domain specific third-party aspect extensions for that language. We present a general mixin-based method for implementing aspect extensions in such a way that multiple, independently developed, dynamic aspect extensions can be subject to third-party composition and work collaboratively

FlashLight: A Dynamic Detector of Shared State, Race Conditions, and Locking Models in Concurrent Java Programs

Concurrent Java programs are difficult to understand and implement correctly. This difficultly leads to code faults that are the source of many real-world reliability and security problems. Many factors contribute to concurrency faults in Java code; for example, programmers may not understand Java language semantics or, when using a Java library or framework, may not understand that their resulting program is concurrent. This thesis describes a dynamic analysis tool, named FlashLight, that detects shared state and possible race conditions within a program. FlashLight illuminates the concurrency within a program for programmers who are wholly or partially in the dark about their software\u27s concurrency. FlashLight also works in concert with the Fluid assurance tool to propose Greenhouse-style lock policy models based on a program\u27s observed locking behavior. After review by a programmer to ensure reasonableness, these models can be verified by the Fluid assurance tool. The author\u27s combination of a dynamic tool with a program verification system focused on concurrency fault detection and repair is the primary contribution of this research. He applied FlashLight to several concurrent Java programs, including a large commercial web application server. His case study experiences induced him to improve FlashLight to do the following: (1) allow the programmer to specify interesting time quantums (e.g., this is the start-up phase of the program), and (2) support the common Java programming idiom of not locking shared state during object construction. Both improvements help to reduce false positives. FlashLight introduces an overhead of roughly 1.7 times the original execution time of the program. The most significant limitation of FlashLight is that it is not fully integrated into the Fluid assurance tool with respect to the user experience

Reusable aspect-oriented implementations of concurrency patterns and mechanisms

In this paper, we present a collection of well-known high-level concurrency patterns and mechanisms, coded in AspectJ. We discuss benefits of these implementations relative to plain Java implementations of the same concerns. We detect benefits from using AspectJ in all the cases presented, in the form of higher modularity, reuse, understandability and unpluggability. For most of the implementations, two alternatives can be used: one based on traditional pointcut interfaces and one based on annotations.Fundo Europeu de Desenvolvimento Regional (FEDER).Fundação para a Ciência e a Tecnologia (FCT) - PPC-VM Project POSI/CHS/47158/2002; Project SOFTAS (POSI/EIA/60189/2004)

An Aspect Refactoring Tool for The Observer Pattern

Current integrated development environments such as Eclipse provide strong support for object- oriented automatic refactorings; however, the same cannot be said about aspect-oriented refactor- ings. Refactoring of design patterns is one area where aspect refactoring automation remains to be explored in depth and few current tools are available to support it. To support aspect refactoring tools we present the AJRefactor plug-in, a semi-automatic refactoring tool for the observer pattern, a widely-used solution in the design of object-oriented programs. Aspect refactoring of the observer pattern allows aspects to capture pattern-specific code into a more modularized unit, and local- izes the code of participating classes. After applying AJRefactor on two Java projects JHotDraw and Prevayler, the results showed that AJRefactor was able to refactor 75% of the total observer instances found in both projects. Also, the refactoring enhanced the modularity and loosens the coupling of the pattern classes. Finally, the results showed a significant time savings and a small reduction in code size when refactoring with AJRefactor

Aspect-Oriented Programming for Test Control

Distributed and multithreaded systems are usually much more complex to analyze or test due to the nondeterminism involved. A possible approach to testing nondeterministic systems is to direct the execution of the program under test to take a certain path for each test, so that a unique output can be observed. Considering specification-based testing, we assume that a test case is given together with a test constraint for directing the internal nondeterministic choices. To instruct the program under test to execute according to a given test constraint, the program under test needs to communicate with the tester. In this thesis, we propose to use the features in Aspect-Oriented Programs to realize such communication. This solution does not require the availability of the source code of the program under test. We provide an automated translation from a test constraint to a set of aspects using AspectJ

Feature-Oriented Specification of Hardware Bus Protocols

Hardware engineers frequently create formal specification documents as part of the verification process. Doing so is a time-consuming and error-prone process, as the primary documents for communications and standards use a mixture of prose, diagrams and tables. We would like this process to be partially automated, in which the engineer\u27s role would be to refine a machine-generated skeleton of a specification\u27s formal model. We have created a preliminary intermediate language which allows specifications to be captured using formal semantics, and allows an engineer to easily find, understand, and modify critical portions of the specification. We have converted most of ARM\u27s AMBA AHB specification to our language; our representation is able to follow the structure of the original document

AOmpLib: an aspect library for large-scale multi-core parallel programming

This paper introduces an aspect-oriented library aimed to support efficient execution of Java applications on multi-core systems. The library is coded in AspectJ and provides a set of parallel programming abstractions that mimics the OpenMP standard. The library supports the migration of sequential Java codes to multi-core machines with minor changes to the base code, intrinsically supports the sequential semantics of OpenMP and provides improved integration with object-oriented mechanisms. The aspect- oriented nature of library enables the encapsulation of parallelism-related code into well-defined modules. The approach makes the parallelisation and the maintenance of large-scale Java applications more manageable. Furthermore, the library can be used with plain Java annotations and can be easily extended with application- specific mechanisms in order to tune application performance. The library has a competitive performance, in comparison with traditional parallel programming in Java, and enhances programmability, since it allows an independent development of parallelism-related code.This work is funded by ERDF - European Regional Development Fund through the COMPETE Programme (operational programme for competitiveness) and by National Funds through the FCT - Fundação para a Ciência e a Tecnologia (Portuguese Foundation for Science and Technology) within projects FCOMP-01-0124-FEDER- 011413 and FCOMP-01-0124-FEDER-010152

Dynamic Assignment of Scoped Memory Regions in the Translation of Java to Real-Time Java

Advances in middleware, operating systems, and popular, general-purpose languages have brought the ideal of reasonably-bound execution time closer to developers who need such assurances for real-time and embedded systems applications. Extensions to the Java libraries and virtual machine have been proposed in a real-time Java standard, which provides for specification of release times, execution costs, and deadlines for a restricted class of threads. To use such features, the programmer is required to use unwieldy code constructs to create region-like areas of storage, associate them with execution scopes, and allocate objects from them. Further, the developer must ensure that they do not violate strict inter-region reference rules. Unfortunately, it is difficult to determine manually how to map object instantiations to execution scopes. Moreover, if ordinary Java code is modified to effect instantiations in scopes, the resulting code is difficult to read, maintain, and reuse. We present a dynamic approach to determining proper placement of objects within scope-bounded regions, and we employ a procedure that utilizes aspect-oriented programming to instrument the original program, realizing the program’s scoped memory concerns in a modular fashion. Using this approach, Java programs can be converted into region-aware Java programs automatically

A comparison of Jiazzi and AspectJ for feature-wise decomposition

technical reportFeature-wise decomposition is an important approach to building configurable software systems. Although there has been research on the usefulness of particular tools for featurewise decomposition, there are not many informative comparisons on the relative effectiveness of different tools. In this paper, we compare AspectJ and Jiazzi, which are two different systems for decomposing Java programs. AspectJ is an aspect-oriented extension to Java, whereas Jiazzi is a component system for Java. To compare these systems, we reimplemented an AspectJ implementation of a highly configurable CORBA Event Service using Jiazzi. Our experience is that Jiazzi provides better support for structuring the system and manipulating features, while AspectJ is more suitable for manipulating existing Java code in non-invasive and unanticipated ways