Proposals for large scale software reuse typically introduce some concept of a software component along with a design and implementation framework which allows component composition.  One of the greatest inhibitors to large scale reuse is the problem of code tangling or cross-cutting features.  Implementing new features that require changes to many components intermixes unrelated code at various sites and disseminates logically connected code throughout the code base.  Over time, the original design is obscured and the code becomes harder to understand and maintain.  Various approaches to software design have been proposed in which a logical feature is encapsulated as a single entity.  These approaches are current topics of research and each one conceptualizes its component framework using its own unique perspective and vocabulary.  It is important to understand commonalties that may exist between these approaches to gain insight into intrinsic principles at work.  This discussion relates two such approaches and explores the significance of the commonalties found.

2 Position

Aspect-Oriented Programming (AOP) and GenVoca, though seemingly dissimilar in approach and technology, are very similar in their basic concepts and the effort required for their implementation.

3 Approach

3.1 Fundamental Concepts

AOP starts with user-written components that cleanly encapsulate some application function in code.  AOP components can be methods, classes, etc.  AOP then applies one or more aspects to these components to perform large-scale refinements.  Aspects implement design features that may modify or cross-cut multiple components.  All modifications take place at predefined join points.  Join points may be as generic as constructs in the host programming language or as specific as code markers unique to an application.

GenVoca, on the other hand, defines standardized interfaces called realms which may contain multiple classes and their methods.  GenVoca components are modules that export a realm interface and encapsulate the implementation of a single design feature.  GenVoca components may also import realm interfaces allowing components to be parameterized by other components.  Such compositions are specified in type equations.  Each component implements a large scale refinement; a composition of components represents a composition of such refinements.

Though AOP and GenVoca have different starting points, both begin with some encapsulated representation of system function (AOP component, GenVoca realm) and provide a mechanism to define and apply large-scale refinements (AOP aspects, GenVoca components) at specific sites (AOP join points, parameters in GenVoca components).

3.2 Implementation

There are certain issues that have been dealt with in GenVoca which have not yet been addressed in the AOP literature.  For example, not all compositions of GenVoca components are correct.  General algorithms for validating the component compositions have been developed [Bat97a].  Corresponding validation problems will surface when multiple AOP aspects are composed.  For optimization purposes, some GenVoca implementations allow interactaction between components at composition time [Bat93, Bat98].  Similar techniques may be required for  AOP aspects to generate efficient code in similar circumstances.  GenVoca type equations can be automatically rewritten using expert knowledge to express a more optimized application design [Bat98].  The same type of built-in guidance would also be valuable to AOP users composing large numbers of aspects at once.

3.3 Focus

GenVoca requires the definition of standardized realm interfaces as its starting point.  This is usually preceded by a domain analysis which reveals what standardized interfaces should be supported.  Each interface defined represents a subsystem abstraction whose implementations are specified by families of subsystems (type equations), called an application family.

Whereas GenVoca provides techniques to decompose existing applications into reusable and composable components, AOP supports the reuse of existing code by applying new features in a controlled and localized way.

3.4 Assessment

These two approaches start with different assumptions and use ostensibly different techniques to support software refinement.  How can so many parallels be drawn between the two approaches?  The answer lies in the fact that both  perform software refinements at the same scale.  There may be a common conceptual framework underlying both approaches or, more generally, any approach to large-scale refinement.  Identifying such an abstraction would be important step in realizing the goal of reusable software componentry.  The study of the  AOP-GenVoca relationship provides one data point in this effort.

At this point, the fundamentals of large-scale software refinement can only be conjectured.  Exploring the relative expressive powers of AOP and GenVoca may help uncover underlying principles.  It's safe to say there's significant overlap in the transformations that can be easily and naturally expressed using either approach.  The exact extent of this overlap is an area for further study.

4 Related Work

In addition to the GenVoca [Bat*] and Aspect-Oriented Programming [Kic97, Lop97, Men97] papers,  ideas contributing to recent research in the area of reusable and composable software include subjectivity [Har93],  design patterns [Gam94, Tok95], frameworks [Boh98, Joh97, Mil97], software architectures [Sha95, Per92], and layered component systems [Ren96].

5 Acknowledgements

I thank Don Batory for his support and guidance on this work.

6 References

Richard Cardone (richcar@cs.utexas.edu) Department of Computer Sciences, University of Texas at Austin, http://www.cs.utexas.edu/users/richcar.

I'm currently a Ph.D. student at the University of Texas working with Professor Batory on topics of software component composition and reuse.  Interest in this area is the net result of twelve years of work as a professional programmer.  I earned a B.S in Mathematics from the State University of NY at Oneonta, Oneonta, NY, and an M.S. in Computer Sciences from Polytechnic University, Hawthorne, NY.