Aspect Oriented Programming (AOP) provides mechanisms for the separation of crosscutting concerns – functionalities scattered through the system and tangled with the base code. Existing systems are a natural testbed for the AOP approach, since they often contain several crosscutting concerns which could not be modularized using traditional programming constructs. This paper presents an automated approach to the problem of migrating systems developed according to the Object Oriented Programming (OOP) paradigm into Aspect Oriented Programming (AOP). A simple set of six refactorings has been defined to transform OOP to AOP and has been implemented in the AOP-Migrator tool, an Eclipse plug-in. A set of enabling transformations from OOP to OOP complement the initial set of refactorings. The paper presents the results of four case studies, which use the approach to migrate selected crosscutting concerns from medium–sized Java programs (in the range 10K to 40K lines of code) into equivalent programs in AspectJ. The case study results show the feasibility of the migration and indicate the importance of the enabling transformations as a pre-processing step. 1

Abstract. For some organizations, the proactive approach to product lines may be inadequate due to prohibitively high investment and risks. As an alternative, the extractive and the reactive approaches are incremental, offering moderate costs and risks, and therefore sometimes may be more appropriate. However, combining these two approaches demands a more detailed process at the implementation level. This paper presents a method for extracting a product line and evolving it, relying on a strategy that uses refactorings expressed in terms of simpler programming laws. The approach is evaluated with a case study in the domain of games for mobile devices, where variations are handled with aspect-oriented constructs. 1

In this paper, we contribute to the characterisation of a programming style specific to aspect-oriented programming. For this purpose, we present a collection of refactorings for aspect-oriented source code, comprising refactorings to enable extraction to aspects of crosscutting concerns from objectoriented legacy code, the subsequent tidying up of the extracted aspects and factoring out of common code from similar aspects to superaspects. The second group of refactorings is documented in detail. In addition, we propose some new aspect-oriented code smells, including one smell that is specific to aspect modules. We also propose a reinterpretation of some of the traditional objectoriented code smells in the light of aspect-orientation, to detect the presence of crosscutting concerns.

In this paper we evaluate logic code analysis and transformation frameworks for their suitability as basic infrastructures for fast detection and extraction of (crosscutting) concerns. Using design patterns as example concerns, we identify desirable properties that an infrastructure should fulfill. We then report our initial results of evaluating candidate systems with respect to these properties. We show how high precision design pattern detectors can be easily formulated as predicates that are evaluated in mere seconds even on the sources of large software systems, such as the Eclipse IDE. Although details still remain to be analyzed further, our current results suggest that the pair JTransformer & CTC is a good candidate for a general infrastructure, combining very good querying performance, scalability and short turnaround times with a seamless integration of querying and transformation capabilities.

Despite the automated refactoring support provided by today’s IDEs many program transformations that are easy to conceptualize— such as improving the implementation of a design pattern—are not supported and are hence hard to perform. We propose an extension to the refactoring paradigm that provides for the modular maintenance of crosscutting design idioms, supporting both substitutability of design idiom implementations and the checking of essential constraints. We evaluate this new approach through the design and use of Arcum, an IDE-based mechanism for declaring, checking, and evolving crosscutting design idioms.

This paper provides an overview of the three different kinds of AOP refactorings: aspect-aware OO refactorings, refactorings for AOP constructs, and refactorings of crosscutting concerns. We discuss recent developments for each of them and highlight their commonalities with respect to associated challenges and ties to related research, such as program analysis and aspect mining. 1.

Abstract. Aspect-oriented (AO) software development is an emerging paradigm that provides new abstractions and mechanisms to support the modularization of crosscutting concerns through the software development. However, the achievement of high-quality AO software is not trivial. The inappropriate use of aspect-oriented abstractions and mechanisms potentially leads to the violation of important design principles, such as low coupling, high cohesion, incomplete modularization of crosscutting concerns into aspects, and so forth. These problems are not easily detectable and an ad hoc analysis of large designs and implementations is often expensive and time-consuming. Hence there is a need for an assessment method that assists software engineers in the analysis of their AO designs and implementations. This paper reports our efforts in the ongoing development of a systematic approach to support the quantitative assessment of aspect-oriented artifacts generated through the system design and implementation. The approach is organized in a stepwise fashion and is founded on a metrics suite and a comprehensive set of complementary rules. Our proposal is supported by a prototype measurement tool and has been applied to four medium-sized software systems in different domains and with distinct degrees of complexity. 1

Abstract. One of the main problems in Aspect-Oriented Software Development is the so-called fragile pointcut problem. Uncovering and specifying a good robust pointcut is not an easy task. In this paper we propose to use Inductive Logic Programming, and more specifically the FOIL algorithm, to automatically identify intensional (or “pattern-based”) pointcuts. We present the tool chain we implemented to induce a pointcut given a set of identified joinpoints. Using several realistic medium-scale experiments, we show that our approach is able to automatically induce robust pointcuts for a set of joinpoints. 1

Aspect-mining techniques help to identify crosscutting structure that could potentially be modularized through objectoriented (OO) or aspect-oriented refactoring (AO). This paper describes a case study in which we used aspect-mining techniques to identify and refactor crosscutting concerns using aspect-oriented programming. We observed that, in our case, there were many subtle variations in the implementation of the concerns that made them non-trivial to modularize with AO refactoring. In the end, we solved our modularization problem using traditional OO refactoring. We conclude that there exists an important gap between the identification of crosscutting concerns and the technologies available to mitigate the problem. 1.

Aspect-based refactoring, called aspectualization, involves moving program code that implements cross-cutting concerns into aspects. Such refactoring can improve the maintainability of legacy systems. Long compilation and weave times, and the lack of an appropriate testing methodology are two challenges to the aspectualization of large legacy systems. We propose an iterative test driven approach for creating and introducing aspects. The approach uses mock systems that enable aspect developers to quickly experiment with different pointcuts and advice, and reduce the compile and weave times. The approach also uses weave analysis, regression testing, and code coverage analysis to test the aspects. We developed several tools for unit and integration testing. We demonstrate the test driven approach in the context of large industrial C++ systems, and we provide guidelines for mock system creation. Key words: mock systems, aspect oriented programming, legacy systems, refactoring, testing 1