Coupling is an internal software attribute that can beused to indicate the degree of interdependence among thecomponents of a software system. Coupling is thought tobe a desirable goal in software construction, leading to bettervalues for external attributes such as maintainability,reusability, and reliability. Aspect-oriented software development(AOSD) is a new technique to support separation ofconcerns in software development. In aspect-oriented (AO)systems, the basic components are aspects or classes, whichconsist of attributes (aspect or class instance variables) andthose modules such as advice, intertype declarations, pointcuts,and methods. Thus, in AO systems, the coupling ismainly about the degree of interdependence among aspectsand/or classes. To test this hypothesis, good coupling measuresfor AO systems are needed. In this paper, we proposea coupling measure suite for assessing the coupling inaspect-oriented systems. We first present a coupling frameworkfor AO systems which specially designed to count thedependencies between aspects and classes in the systems.Based on this framework, we formally define various couplingmeasures in terms of different types of dependenciesbetween aspects and classes. We also discuss the mathematicalproperties of these measures.

Cohesion is an internal software attribute representing thedegree to which the components are bound together within a softwaremodule. Cohesion is considered to be a desirable goal in software development,leading to better values for external attributes such as maintainability,reusability, and reliability. Aspect-oriented software development(AOSD) is a new technique to support separation of concerns in softwaredevelopment. AOSD introduces a new kind of component called aspectwhich is like a class, also consisting of attributes (aspect instance variables)and those modules such as advice, introduction, pointcuts, andmethods. The cohesion for such an aspect is therefore mainly about howtightly the attributes and modules of aspects cohere. To test this hypothesis,cohesion measures for aspects are needed. In this paper, we proposean approach to assessing the aspect cohesion based on dependence analysis.To this end, we present various types of dependencies between attributesand/or modules in an aspect, and the aspect dependence graph(ADG) to explicitly represent these dependencies. Based on the ADG,we formally define some aspect cohesion measures. We also discuss theproperties of these dependencies, and according to these properties, weprove that these measures satisfy the properties that a good measureshould have.

Although a large body of research in software metrics has benn focused on procedural of object-oriented software, there is no software metric for aspect-oriented software until now. In this paper, we propose some metrics for aspect-oriented In this paper, we propose some metrics for aspect-iruebted siftwarem which are specifically designed to quantify the in-formation flows in an aspect-oriented program. We define these metrics based on a dependence model for aspect-oriented soft ware which consists of a group of depentence graphs each can be used to explicitly represent various dependence rela-tions at different levels of an aspect-oriented program. The proposed metrics can be used to measure the complexity of an aspect-oriented program frm various different.

We extend previous depedence-based representations called system dependence graphs (SDGs) to represent aspect-oriented programs and present an SDG construction algorithm. This algorithm first constructs a module dependence graph (MDG) for each piece of advice, introduction, and method in aspects and classes. It then uses existing techniques to connect the MDGs at call sites to form a partial SDG. Finally, it weaves the MDG for each eice of advice into the partial SDG for those methods whose behavior may be affected by the ad-vice. The result is the complete SDG. Our SDGs capture the additional structure present in many as pect-oriented fea-tures such as join points, advice, introuduction, aspects, and aspect in heritance, and various types of interactions between aspects and classes. They also correctly reflect the semantics of aspect-oriented concepts such as advice precedence, intro-duction scope, and aspect weaving. SDGs therefore provide a solid foundation for the further analysis of aspect-oriented programs.

Pipa is a behavioral interface specification language (BISL)tailored to AspectJ, an aspect-oriented programming language. Pipa isa simple and practical extension to the Java Modeling Language (JML),a BISL for Java. Pipa uses the same basic approach as JML to specifyAspectJ classes and interfaces, and extends JML, with just a few newconstructs, to specify AspectJ aspects. Pipa also supports aspect specificationinheritance and crosscutting. This paper discusses the goals andoverall approach of Pipa. It also provides several examples of Pipa specificationsand discusses how to transform an AspectJ program togetherwith its Pipa specification into a corresponding Java program and JMLspecification. The goal is to facilitate the use of existing JML-based toolsto verify AspectJ programs.