We investigate potential uses of aspect-oriented programming in the context of object-oriented C++ frameworks used in the development of VLSI CAD applications. We use existing applications to explore the use of different kinds of aspects. We differentiate between framework-based aspects and application-specific aspects. Framework-based aspects modularize cross-cutting code based on how an application uses or extends an object-oriented framework. We propose the use of a library of framework-based aspects that can be developed for and leveraged across a family of frameworkbased applications. Application-specific aspects allow modularizing existing cross-cutting code in VLSI CAD applications. Preliminary results for each type of aspect are presented, along with challenges in identifying and using aspects.

An object-oriented framework enables both black box reuse and white box reuse in client applications, serving as an important infrastructural building block. We are refactoring framework-based applications to modularize cross-cutting concerns with aspects. In this paper, we explore implementation issues we encountered while creating non-functional aspects in AspectC++ that are pluggable and reusable. 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

This paper proposes a principled methodology for the realization of distribution transparencies. The proposed methodology is placed within the general context of Model-Driven Architecture (MDA) development. Specifically, it consists of a UML-based representation for the specification of platform independent models of a system. Moreover, it comprises an automated aspect-oriented method for the refinement of platform independent models into platform specific ones (i.e., models describing the realization of the system’s distribution transparency requirements, based on a standard middleware platform like CORBA, J2EE, COM+, etc.). Finally, the proposed methodology includes an aspect-oriented method for the generation of platform specific code from platform specific models.

Software engineers often rely on communication middleware platforms to design and implement distributed systems. However, middleware functionality is usually invasive, pervasive and tangled with business-specific concerns. In this paper, we describe an aspect-oriented distributed programming system that encapsulates middleware services provided by Java RMI and Java IDL. The proposed system, called DAJ, handles the basic service provided by such object-oriented middleware platforms, i.e., synchronous remote calls using call by-serialization and call by-remote-reference semantics. The paper documents our experience in using DAJ to modularize middleware concerns from three legacy distributed systems.

Aspect-oriented programming (AOP) seeks to improve software modularity via the separation of cross-cutting concerns. AOP proponents often advocate a development strategy where programmers write the main application (base code), ignoring cross-cutting concerns, and then aspect programmers, domain experts in their specific concerns, weave in the logic for these more specialized cross-cutting concerns. This purely oblivious strategy, however, has empirically been shown to tightly couple aspects to base code in many cases, hindering aspect modularity and reuse. In essence, the more intricate the weaving between the cross-cutting concern and the base code (lexically and/or semantically), the harder it becomes to: (a) robustly specify how to weave the aspects in at the required points, (b) capture interactions between aspects and base code, and (c) preserve the correct weaving as the base code evolves. We propose an alternate methodology, termed cooperative aspect-oriented programming (Co-AOP), where complete lexical separation of concerns is not taken as

The primary claimed benefits of aspect-oriented programming (AOP) are that it improves the understandability and maintainability of software applications by modularizing cross-cutting concerns. Before there is widespread adoption of AOP, developers need further evidence of the actual benefits as well as costs. Applying AOP techniques to refactor legacy applications is one way to evaluate costs and benefits. Aspect-based refactoring, called aspectualization, involves moving program code that implements cross-cutting concerns into aspects. Such refactoring can potentially 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