scholarly journals Impact of the Object-oriented Software Evolution on Software Metrics: The Iris Approach

2018 ◽  
Vol 11 (8) ◽  
pp. 1-13
Author(s):  
Ra�Fat AL-Msie�deen ◽  
Anas H. Blasi ◽  
◽  
2019 ◽  
Vol 6 (3) ◽  
pp. 49-66
Author(s):  
Ruchika Malhotra ◽  
Megha Khanna

Software evolution is mandatory to keep it useful and functional. However, the quality of the evolving software may degrade due to improper incorporation of changes. Quality can be monitored by analyzing the trends of software metrics extracted from source code as these metrics represent the structural characteristics of a software such as size, coupling, inheritance etc. An analysis of these metric trends will give insight to software practitioners regarding effects of software evolution on its internal structure. Thus, this study analyzes the trends of 14 object-oriented (OO) metrics in a widely used mobile operating system software, Android. The study groups the OO metrics into four dimensions and analyzes the trends of these metrics over five versions of Android software (4.0.2-4.3.1). The results of the study indicate certain interesting patterns for the evaluated dimensions, which can be helpful to software practitioners for outlining specific maintenance decisions to improve software quality.


Author(s):  
Kecia A. M. Ferreira ◽  
Mariza A. S. Bigonha ◽  
Roberto S. Bigonha ◽  
Heitor C. Almeida ◽  
Luiz F. O. Mendes

1993 ◽  
Vol 19 (4) ◽  
pp. 313-343 ◽  
Author(s):  
K.J. Lieberherr ◽  
C. Xiao

2012 ◽  
Vol 6 ◽  
pp. 420-427 ◽  
Author(s):  
Yeresime Suresh ◽  
Jayadeep Pati ◽  
Santanu Ku Rath

2018 ◽  
Vol 7 (2.27) ◽  
pp. 161
Author(s):  
Pratiksha Sharma ◽  
Er. Arshpreet Kaur

Detection of bad smells refers to any indication in the program code of a execution that perhaps designate a issue, maintain the software and software evolution. Code Smell detection is a main challenging for software developers and their informal classification direct to the designing of various smell detection methods and software tools. It appraises 4 code smell detection tool in software like as a in Fusion, JDeodorant, PMD and Jspirit. In this research proposes a method for detection the bad code smells in software is called as code smell. Bad smell detection in software, OOSMs are used to identify the Source Code whereby Plug-in were implemented for code detection in which position of program initial code the bad smell appeared so that software refactoring can then acquire position. Classified the code smell, as a type of codes: long method, PIH, LPL, LC, SS and GOD class etc. Detection of the code smell and as a result applying the correct detection phases when require is significant to enhance the Quality of the code or program. The various tool has been proposed for detection of the code smell each one featured by particular properties. The main objective of this research work described our proposed method on using various tools for code smell detection. We find the major differences between them and dissimilar consequences we attained. The major drawback of current research work is that it focuses on one particular language which makes them restricted to one kind of programs only. These tools fail to detect the smelly code if any kind of change in environment is encountered. The base paper compares the most popular code smell detection tools on basis of various factors like accuracy, False Positive Rate etc. which gives a clear picture of functionality these tools possess. In this paper, a unique technique is designed to identify CSs. For this purpose, various object-oriented programming (OOPs)-based-metrics with their maintainability index are used. Further, code refactoring and optimization technique are applied to obtain low maintainability Index. Finally, the proposed scheme is evaluated to achieve satisfactory results. The results of the BFOA test defined that the lazy class caused framework defects in DLS, DR, and SE. However, the LPL caused no framework defects what so ever. The consequences of the connection rules test searched that the LCCS (Lazy Class Code Smell) caused structured defects in DE and DLS, which corresponded to the consequences of the BFOA test. In this research work, a proposed method is designed to verify the code smell. For this purpose, different OOPs based Software Metrics with their MI (Maintainability Index) are utilized. Further Code refactoring and optimization method id applied to attained the less maintainability index and evaluated to achieved satisfactory results.    


Author(s):  
Nisha Ratti ◽  
Parminder Kaur

Software evolution is the essential characteristic of the real world software as the user requirements changes software needs to change otherwise it becomes less useful. In order to be used for longer time period, software needs to evolve. The software evolution can be a result of software maintenance. In this chapter, a study has been conducted on 10 versions of GLE (Graphics Layout Engine) and FGS (Flight Gear Simulator) evolved over the period of eight years. An effort is made to find the applicability of Lehman Laws on different releases of two softwares developed in C++ using Object Oriented metrics. The laws of continuous change, growth and complexity are found applicable according to data collected.


Sign in / Sign up

Export Citation Format

Share Document