Procedia Computer Science 62 ( 2015 ) 505 – 512
1877-0509 © 2015 The Authors. Published by Elsevier B.V. This is an open access article under the CC BY-NC-ND license (http://creativecommons.org/licenses/by-nc-nd/4.0/).
Peer-review under responsibility of organizing committee of The 2015 International Conference on Soft Computing and Software Engineering (SCSE 2015)
doi: 10.1016/j.procs.2015.08.523
ScienceDirect
The 2015 International Conference on Soft Computing and Software Engineering (SCSE 2015)
A Theoretical Framework for the Maintainability Model of Aspect
Oriented Systems
Dr.(Mrs).Ananthi Sheshasaayee
a, Mrs.Roby Jose
b aAssociate Professor and Head , Department of Computer Science,Quaid E Millath Govt College for Women,Chennai(TN) 600002 India
b
Research Scholar, Department of Computer Science,Quaid E Millath Govt College for Women,Chennai(TN) 600002 India
Abstract
Aspect Oriented Software Development is gaining wide attention because of its key feature modularization. Aspect Oriented paradigm supports the separation of concerns that are scattered over the system which helps in achieving modularity. Aspect Oriented Software Development encompasses software engineering abstractions and complexity at new and different dimensions. So Aspect Oriented Software Development requires models to assess its external quality attributes. The quality attribute maintainability is vital, because maintenance tasks employs major chunk of the total software development cost. The quality, maintainability is indicated using metrics. This paper proposes a framework to build maintainability model for aspect oriented systems using already defined software measures.
© 2015 The Authors. Published by Elsevier B.V.
Peer-review under responsibility of organizing committee of The 2015 International Conference on Soft Computing and Software Engineering (SCSE 2015).
Keywords: Aspect Oriented Maintenance Metrics ; Aspect Oriented Programming ; Maintainability Model ; Metrics Validation ; Quality Model ; Software Maintenance
1.Introduction
Design of a maintainable aspect oriented system requires the developer to be aware of the phenomena that are observable while the system concerns are being evolved. One such observational phenomenon is static and dynamic measures of software. Since Aspect Oriented Software Development (AOSD) is one of relatively new branch, it should tackle various challenges when compared to the precursor object oriented software development. Of the various issues the position paper is interested in the validation of maintainability metrics.
The aspect oriented systems can be evolved from object oriented systems by altering the static OOP model to meet the new code that should be included to accomplish the further requirements. Thus it could be correctly stated that Aspect Oriented Programming complements Object Oriented Programming but not replaces. Empirical studies © 2015 The Authors. Published by Elsevier B.V. This is an open access article under the CC BY-NC-ND license
(http://creativecommons.org/licenses/by-nc-nd/4.0/).
Peer-review under responsibility of organizing committee of The 2015 International Conference on Soft Computing and Software Engineering (SCSE 2015)
are the evaluation means to study the efficacy of new development paradigm and its associated design principles and practices. Most of the empirical studies in Object Oriented Programming use software metrics as the pointer of the strengths and weaknesses of the approach. In AOP most of the static measures of code, was adopted form object oriented metrics such as Lopes, Briand and CK [16, 18, 23] metrics suite. Apart from these metrics a few metrics capable of capturing the concern modularity specific to the aspect oriented software are also available in the literature [6].
Saraiva et al [3] proposed a metrics suite for the maintainability studies of the aspect oriented systems. But most of these metrics lack a theoretical validation [1].Kitchenham [22] suggests metrics frameworks to validate measures. In addition components which are essential to validate metrics which eventually lead to a quality model is also defined [22].
In this article an attempt is made to propose a framework upon which a maintainability model for aspect oriented systems can be build on. The work is structured as follows. Section 2 presents background information about aspect oriented paradigm. Section 3 drafts the previously completed works in the direction of aspect oriented metrics. A framework for the validation of aspect oriented metrics is discussed in Section 4. The threats to validity are presented in Section 5. The paper is concluded in Section 6.
2.Aspect Orientation
AOSD is a promising paradigm that allows separation of concerns. A concern is a part of the problem that is to be treated as only conceptual unit [17]. These concerns are termed crosscutting concerns as they cut across modularity of other concerns. Aspect Orientation has been proposed as a method for improving separation of concerns [17, 20] in the structure of OO software. AOSD uses aspects as new abstraction and make available mechanisms for creating aspects and components at join point.
In Aspect-Oriented Programming (AOP) modularization is achieved by means of language abstractions that contributes to the modularization of crosscutting concerns (CCs).CCs are concerns which cannot be accurately modularized by using traditional programming paradigms [20]. If not with proper language abstractions, crosscutting concerns become scattered and tangled with other parts of the source code thereby affecting quality attributes like maintainability and reusability. In AOP, there exist clear distinction between base concerns and crosscutting concerns. The base concerns (or Core-concerns) are those which the system was originally designed to deal with. The crosscutting concerns are the concerns which affect on other concerns. Some instances of crosscutting concerns include global restrictions, data persistence, authentication, access control, concurrency and cryptography.
Aspect-Oriented Programming languages have the flexibility that accede programmers to design and implement crosscutting concern detached from the base concerns. The AOP compiler is provided with the facility to weave the decoupled concerns together in order to attain a correct software system. Even though, there is a complete separation of concerns at the source-code level, the final release delivers the functionality expected by the users.
The basic concepts of AOP are illustrated with AspectJ language [14], which is an aspect-oriented extension for Java, allowing the Java code to be compiled seamlessly by the AspectJ compiler. The main constructs in this language are: Aspect - a structure to represent a crosscutting concern; Pointcut - a rule used to capture join points of other concerns; Join Point- A join point is a point of interest in some object of the software lifecycle through which two or more concerns may be composed; JoinPoint model-A JoinPoint model provides the common frame of reference to enable the definition of the structure of aspects; Advices - types of behavior to be executed when a join point is captured; and intertype declarations - the ability to add static declarations from the outside of the affected code.
Initially research on aspect oriented paradigm was concentrated on the building up of design languages and frameworks which facilitates the realization of the modularity. While AOP eliminates tangling of the code in OOP by mining crosscutting concerns and pack them into separate programming module, it also brings about new features which make it intricate to measure the complexity of the software. Further researches on AOP mounted to span all phases of software development lifecycle.
3.State of the art
Software metric is a measure of a software code. Since quantitative measurements are indispensable in all fields of engineering and sciences, there is a continuous effort by computer engineering professionals and scholars to bring similar techniques to software development. The main objective is to find reproducible and quantifiable measurements, which may have numerous valuable applications in schedule and budget planning, cost estimation, quality assurance testing et al. Aspect oriented software metrics is yet an open area for research and there are a few research papers available in this area.
Software metrics can be either static or dynamic. The static analysis of a software or source code can be done to collect static metrics whereas dynamic metrics can be gathered by executing the software application. Static metrics are further divided into four types i) Size (ii) Cohesion (iii) Coupling (iv) Separation of Concerns. SOC is the new software metrics VSHFLDOO\ GHVLJQHG IRU DVSHFW RULHQWHG VRIWZDUH¶V EHFDXVH aspect oriented programming is principally based on separation of concerns.
3.1.Cohesion
Zhao and ;X¶V>11] approach is the first proposal in the field of aspect cohesion measurement. It is based on a dependency model for aspect-oriented software that consists of a group of dependency graphs. According to Zhao
DQG;X¶VDSSURDFKFRKHVLRQLVGHILQHGDVWKHGHJUHH of relatedness between attributes and modules. The authors
were unable to distinguish the connected and non connected graphs and also aspect inheritance was not measured. Gelinas [7] et al. proposed ACOH metric for measuring cohesion and it is compared with existing cohesion metrics for aspect-oriented system [7]. They defined cohesion on the basis of dependence analysis. In their work
WKH\ FRQVLGHUHG WZR FULWHULD¶V IRU PHDVXUHPHQW ± Modules-Modules connection and Modules-Data connection criteria.
In the study [27] the authors has proposed a cohesion framework for aspect oriented systems. The validation of the framework was based upon two programming languages that seamlessly extend Java language. The cohesion metric was examined to determine the effect of metric on reusability of the aspect oriented software.
The investigation [4], by Arora et al. discussed about the aspect-oriented system and its advantage over module-oriented and object module-oriented systems. The major focus of the investigation was on various cohesion metrics available for traditional system as well as for aspect oriented systems.
3.2.Coupling
In [12], Zhao et al. proposed coupling metrics based framework for AspectJ like programming languages. Coupling measures are defined on the number of dependencies between aspect and some classes, i.e. attribute-class, module class, module-method and aspect inheritance dependencies. The authors attempted to present the mathematical properties of the proposed coupling measures, which showed that these measures satisfy properties that a good coupling measure should possess. This framework is useful only for AspectJ family languages.
The authors [10] examined different types of coupling relationships that exist between modules and proposed a new metric. The investigation extended some of the object oriented metrics to suit the programming intricacies required by the aspect orientation. The authors developed tool to capture the metrics, but overlooked the issue of providing an evaluation method for the metrics.
T. Bartolmei et al. proposed a unified coupling framework for AOP [8]. In order to consistently and unambiguously define coupling measurements, they defined new terminologies for representing components of AO systems. In their framework, they considered two AOP languages, AspectJ and CaesarJ. They have extended their
IUDPHZRUNIURP%ULDQG¶V>@IUDPHZRUNVDQGWULHGWRPD[LPL]HWKHXVHRIWKHWHUPLQRORJ\DQGFRXSOLQJFULWHULD RULJLQDOO\GHILQHGLQ%ULDQG¶VIUDPHZRUNV
In [9], Bartsch and Harison suggested a coupling framework for AspectJ, which is an extension of a coupling framework for OO systems, defined by Briand et al. [16].This extended framework contains a specific definition of the different coupling mechanisms found in AspectJ and an additional criterion: instantiation. This paper focused on the evaluation of five aspect-oriented coupling measures.
In [5], R. Burrows et al. applied and compared existing metrics for coupling and other internal attributes [5]. The results show that coupling metrics, which are not directives of object-oriented metrics, tended to be superior indicators of fault-proneness. They derived a new metric called Base-Aspect-Coupling (BAC).
3.3.Separation of concerns
In the study, the authors [13] propose a suite of metrics that captures information about the design and code in term of fundamental software attributes. Based on the proposed metrics a framework that assesses the maintainability of the aspect oriented system was developed.
4. The metrics validation framework
Once the research community institutes that a set of metrics is empirically valid in a number of different systems, organizations can espouse these metrics. The organization can use the validated metrics for three purposes: early identification of high risk software components, to create design and program guidelines and to make system level predictions. The identification of high risk components is realized using quality model. As earlier stated, the position paper is interested in maintainability. Maintainability of an object oriented software system can be assessed using metrics [24]. Since Aspect Oriented Systems complement object oriented systems, it can be said that aspect oriented metrics can be utilized to assess the maintainability of aspect oriented systems. An overview of the quality model of aspect oriented system for maintainability is shown in Fig 1.
Fig. 1. Aspect Oriented Maintainability Model
The maintainability model is formed using a statistical or machine learning approaches or a combination of these approaches. The quality model takes as input the set of aspect oriented metrics (m1«Pn) for the entire system and produces the prediction of maintainability for the system using regression or similar machine learning approaches.
Since the maintainability model is based upon the set of metrics it is important that the product metrics under study is properly validated. Briand et al [21] point that neither theoretical nor empirical kind of validation is sufficient by itself. It is pointed that both the validation is to be performed on the metric for it to be valid. Theoretical validation demonstrates that the metric actually measures what it claims to measure. Empirical validation on the other hand is an on-going activity which amasses convincing evidence that the metric is useful. The more the evidence gathered, the higher the degree of validity.
4.1 Influence of the maintainability model
A substantial contribution for the success of software community can be acknowledged to commonly defined model of maintainability. It would have a strong impact on the standards of the software industry and academia. In industry, a maintainability model perks up the working milieu of the software engineer. A maintainable system is an understandable, traceable, measurable and testable system. The exertion needed to make changes to a maintainable system is substantially less. The metrics based maintainability model enables the software
mn . . . . . . . m1 QUALITY MODEL Predict Maintainability
organizations in providing the quality guidelines for developing a maintainable system and evaluate the product. The organizations could achieve better insight into the products and processes, and their effects on each other. This would in turn improve business decision making and lower the costs. In an open source framework, a quality model would ensure that the product controlled by different engineers matches the maintainability standards.
In the academic research a model would provide groundwork for various approaches, which offer basis for the modification or extension of the current standards, and for developing new ones.
4.2 Analysis of the framework for maintainability model of aspect oriented systems
The maintainability metrics under evaluation capture information about code in terms of software attributes such as coupling, concern level separation and size.
The proposed framework is for assessing the perfective maintenance of aspect oriented system. The input set of metrics as represented in Table 1 is static metrics. Unlike the study [2], which proposes an assessment framework for maintainability of aspect oriented systems based on dynamic metrics the position study is about a validation framework of static metrics against maintainability.
Table 1.Aspect Oriented Metrics for maintainability.
Metrics Description of the metrics
WOM Weighted Operations in module
Response For a Module Coupling on Advice Execution Crosscutting Degree of Aspect Coupling on Intercepted Module Coupling on Field Access Coupling Between Modules Lack Of Cohesion in Operation Lines Of Class Code RFM CAE CDA CIM CFA CBM LCCO LOCC
The analysis proposed here is being carried out by using the methodology [15] that is based upon the actual experiences in software engineering and other disciplines where validation is very common. In Fig 2. the methodology is represented as a sequence of steps.
Step 1 Step 2 Step 3
Fig. 2. Overview of validation process
A theory is stated at an abstract level, relating internal attributes of the product with external qualities. Also a theory should stipulate the means which explains the existence of such relations. To operationalize a theory and test it empirically the abstract definitions have to be converted to measurable parameters. For instance the Parnas [28] theory states that high cohesion within modules and low coupling across modules are the desirable design attributes for a system which can be easily modified, understood and maintained. So it is essential that an operational definition for coupling, cohesion, modifiability, understandability and maintainability are given. In this scenario
Strategize Statistical Modelling
Post Modelling
software product measures evolve for measuring coupling, cohesion et al. How to measure maintainability or similar quality attributes is the question. Some studies used [24] [25] number of changes made to the code as the surrogate measure of maintenance. This analysis uses the revision history made to the systems as the surrogate measure for maintainability.
The framework as illustrated in Figure 3 is composed of four major sections (i) Theoretical justification for software product measures (ii) Analytic study of the model (iii) Model Building and (iv) Maintainability model.
The framework components help in structuring the validation process after the dataset is collected. The initial section verifies if a homomorphism exists between the empirical relation system and the numerical relational set [19][26]. The second component supports in the decision of data analysis technique. For analyzing data, which technique to be used is based on the type of dependent variable.
The model specification is supported by the decision on the approach, be it statistical or machine learning to be used. Some of the other issues addressed in the section are specification of the functional form of relation between dependent variable and product metrics, interaction between independent variables et al. The strategy for building model is to form a subset of metrics that are related with dependent variable. The output of this section will be identification of metrics capable of predicting maintainability. Finally the model is to be evaluated for the prediction accuracy. Here again the coefficient to characterize prediction accuracy is decided upon by the dependent variable.
Fig. 3. Framework for aspect oriented maintenance metrics validation
5. Threat to Validity
The proposed framework is based upon the static metrics already available in literature. The framework is only theoretical; the concrete outcome depends on the actual implementation of the model with the data collected from aspect oriented software systems. The analytic study does not hold conclusion validity for measuring maintenance effort. The conclusion validity is not mitigated in this analytic study. The authors assume that the revision history is attributable to maintenance efforts. The internal validity for this analytic study requires controlled experiment to be done based on this assumption.
Validation of the design of measurement
Data analysis technique Model Specification
Evaluate validity of metrics Build the prediction model Use PCA for variable selection
6. Conclusion
Aspect orientation is a rewarding change. But the paradigm is at its burgeoning stage. Measurement of the object oriented paradigm was given a solid philosophical basis through Chidamber Kemerer and Li Henry. Aspect Orientation also needs to be matured on the lines of object oriented with respect to measurement and prediction features of metrics.
In this paper a framework using a set of static metrics is proposed to calculate the quality attributes for aspect
RULHQWHG VRIWZDUH¶V 7KHUHDIWHU DQ DVSHFW RULHQWHG PDLQWDLQDELOLW\ PRGHO EDVHG RQ WKHVH VWDWLF PHWULFV LV GHULYHG
This research paper provides the theoretical framework based on the related wRUNGRQHRQDVSHFWRULHQWHGVRIWZDUH¶V
for assessing the quality attributes for predicting various parameters like maintainability, changeability, reusability, testability etc.
References
1. Sheshasaayee, Ananthi, and Roby Jose. International Journal of Emerging Technologies in Computational and Applied Sciences (IJETCAS), 8(5) (2014) pp 382-386.
2. Singh, Pradeep Kumar, and Om Prakash Sangwan. "Aspect Oriented Software Metrics Based Maintainability Assessment: Framework and Model." (2013): 1-07.
3. Saraiva, Juliana, et al. "Aspect-oriented software maintenance metrics: A systematic mapping study." Evaluation & Assessment in Software Engineering (EASE 2012), 16th International Conference on. IET, 2012.
4. Arora, K., Singhal, A., & Kumar, A. A Study of Cohesion Metrics for Aspect Oriented Systems,IJESAT, 2012
5. Burrows, R., Ferrari, F. C., Garcia, A., & Taïani, F. (2010, May). An empirical evaluation of coupling metrics on aspect-oriented programs. In Proceedings of the 2010 ICSE Workshop on Emerging Trends inSoftware Metrics (pp. 53-58). ACM.
6. Figueiredo, Eduardo, et al. "On the maintainability of aspect-oriented software: A concern-oriented measurement framework." Software Maintenance and Reengineering, 2008. CSMR 2008. 12th European Conference on. IEEE, 2008.
7. Gélinas, J. F., Badri, M., & Badri, L. (2006). A Cohesion Measure for Aspects. Journal of object technology, 5(7), 75-95.
8. Bartolomei, T. T., Garcia, A., Sant'Anna, C., &Figueiredo, E. (2006, November). Towards a unified coupling framework for measuring aspect-oriented programs. In Proceedings of the 3rd internationalworkshop on Software quality assurance (pp. 46-53).ACM.
9. Bartsch, Marc, and Rachel Harrison. "An evaluation of coupling measures for AspectJ." LATE Workshop AOSD. 2006.
10.Ceccato, Mariano, and Paolo Tonella. "Measuring the effects of software aspectization." 1st Workshop on Aspect Reverse Engineering. Vol. 12. 2004.
11. Zhao, Jianjun, and Baowen Xu. "Measuring aspect cohesion." Fundamental Approaches to Software Engineering. Springer Berlin Heidelberg, 2004. 54-68.
12. Zhao, J. (2004, September). Measuring coupling in aspect-oriented systems. In Proc. of 10th IEEE International Soft. Metrics Symposium (METRICS'04),Chicago,USA.
13.6DQW¶$QQD&OiXGLRHWal. "On the reuse and maintenance of aspect-oriented software: An assessment framework." Proceedings of Brazilian Symposium on Software Engineering. 2003.
14.Kiczales, Gregor, et al. "An overview of AspectJ." ECOOP 2001²Object-Oriented Programming. Springer Berlin Heidelberg, 2001. 327-354.
15.El-Emam, Khaled. "A methodology for validating software product metrics." (2000).
16. %ULDQG / 'DO\ - :VW - ³$ 8QLILHG )UDPHZRUN for Coupling Measurement in Object-2ULHQWHG 6\VWHPV´ ,((( 7UDQV RQSoftware Engineering, 25(1), 1999, pp 91-121.
17. Tarr, Peri, et al. "N degrees of separation: multi-dimensional separation of concerns." Proceedings of the 21st international conference on Software engineering. ACM, 1999.
18. /RSHV&³'$ /DQJXDJH )UDPHZRUNIRU'LVWULEXWHG3URJUDPPLQJ´3K'7KHVLV&ROOHJHRI&RPSXWHU6FLHQFH1RUWKHDVWHUQ8QLYHUVLW\ 1997.
19.Zuse, Horst. A framework of software measurement. Walter de Gruyter, 1998. 20. Kiczales, Gregor, et al. Aspect-oriented programming. 11th
European Conference on Object Oriented Programming in: LNCS, vol.1241, Springer Verlag,1997,pp 220-242 1997.
21. Briand, Lionel, Khaled El Emam, and Sandro Morasca. "Theoretical and empirical validation of software product measures." International Software Engineering Research Network, Technical Report ISERN-95-03 (1995).
22.B. Kitchenham, S-L Pfleeger, and N. Fenton, "Towards a Framework for Software Measurement Validation," IEEE Transactions on Software Engineering, vol. 21, no. 12, pp. 929-944, 1995.,
23.S.R.Chidamber and C.F. Kemerer. A metrics suite for object oriented design. IEEE transactions on Software Engineering, 20(6):476-493, June 1994
25.S. Henry and S. Wake, "Predicting Maintainability with Software Quality Metrics," Software Maintenance: Research and Practice, vol. 3, pp. 129-143, 1991.
26.Fenton, Norman. "Software Metrics: A Rigorous Approach. 1991." Chapman & may,.
27. Avadhesh Kumar, Rajesh Kumar, P.S. Grover. Towards a Unified Framework for Cohesion Measurement in Aspect Oriented Systems. $6:(&¶
28.D. Parnas, "On the Criteria to be Used in Decomposing Systems into Modules," Communications of the ACM, vol. 14, no. 1, pp. 221-227, 1972.
