Code Complexity Metrics for Mobile Agents Implemented with Aspect/J™

The article describes the approach to the assessment of code reuse in Dynamic Product Line lines (DSPL). Some existing mechanisms to realize software variability in DSPL, such as machine learning, adaptive configurations based on Java programming tools which allow developing DSPL, especially in mobile applications domain, have been reviewed. During the development, some methods for the implementation of the variability specific to the selected programming language have been tested. For each of these mechanisms, such as Weighted Methods per Class, Response for a Class, Depth of Inheritance Tree, Coupling Between Objects, Number of Children, the code complexity metrics have been calculated. Based on these results the code reusability extent can be estimated for each of given variation mechanisms.

Download Full-text

Measuring Code Complexity in Projects Designed with Aspect/J

10.28945/2611 ◽

2003 ◽

Cited By ~ 1

Author(s):

Jana Dospisil

Keyword(s):

Mobile Agents ◽

Separation Of Concerns ◽

Software Complexity ◽

Agent Interaction ◽

Class Hierarchies ◽

Complexity Estimation ◽

Reduced Complexity ◽

Code Complexity ◽

Object Interactions ◽

Java Code

The modularized code encapsulating object interactions is characterized by class hierarchies. In the implementation of mobile agents, we have observed that the changes in agent interaction protocols lead to uncontrolled subclassing and consequently to disorder. This phenomenon is known as entropy. The additional subclassing, modification to protocols, restructuring of the class hierarchies, changes to visibility of attributes, and method overloading result in increased co mplexity of the code. This problem in agent design has been tackled by Kendall (Kendall, 1999) who proposed development using Aspect/J and separation of concerns. Since there has been no proof of reduced complexity, we have proposed metrics for software complexity estimation, and ranking of compositional elements developed with As-pect/J. The metrics have been tested on Java code for mobile agents.

Download Full-text

Measuring the Complexity of Mobile Agents Designed with Aspect/J

10.28945/2615 ◽

2003 ◽

Cited By ~ 1

Author(s):

Jana Dospisil ◽

Arin Khemngoen

Keyword(s):

Mobile Agent ◽

Mobile Agents ◽

Protocol Design ◽

Fine Tuning ◽

Separation Of Concerns ◽

Complexity Measures ◽

Agent Interactions ◽

Java Application ◽

Class Hierarchies ◽

Code Complexity

This paper describes research in measuring the code complexity of mobile agent applications designed with aspect-oriented programming (AOP) as captured in the AspectJ™ language. The modularized code encapsulating agent interactions is characterized by class hierarchies which are shared structures. Mobile agent design suffers from frequent changes in interaction protocols which leads to chaotic development. Additional subclassing, modification to protocols, restructuring of the class hierarchies, changes to visibility of attributes and methods overloading result in increased complexity of the code and disorder. Our experonce with fine tuning of protocols shows that the probability that a subclass will not consistently extend the protocol content of its superclass is increasing with the depth of hierarchy. The tools like Hyper/Jand Aspect/J support the separation of concerns thus allowing different approach to evolving the protocol content rather than extending the class hierarchies. In this paper we present the approach to analyzing protocol design and assessing the complexity by measuring the entropy of the mobile agent application code designed with Aspect/J. The comparison of complexity measures with the same mobile agent application designed and maintained as typical Java application indicates reduction in complexity in favor of design with Aspect/J.

Download Full-text