Gene Based Software Refactoring Location Identification and Rectification For Software Code Quality Maintenance

GENE BASED SOFTWARE REFACTORING LOCATION
IDENTIFICATION AND RECTIFICATION FOR
SOFTWARE CODE QUALITY MAINTENANCE
M.Sangeetha1
1.Research Scholar ,Department of Computer Science, Periyar University PG Extension centre, Dharmapuri, Tamilnadu, India
Dr.P.Sengottuvelan 2
2. Associate Professor, Department of Computer Science, Periyar University PG Extension centre, Dharmapuri, Tamilnadu, India
ABSTRACT
Software refactoring is the process of changing the inner structure of object-oriented software to
enhance the quality of software code, especially in terms of maintainability, extensibility, and reusability
while software outer performance remains unchanged. In order to improve software refactoring, several tools
has been employed for code smell detection. However, these tools are inactive and human driven, hence it
making software refactoring maintained by developer’s inconsistency. A monitor-based instant refactoring
approach failed to handle number of code smells and reduced software quality with more software cost. In
order to improve the software code quality maintenance, Gene based Software Refactoring Location
Identification and Rectification (GSR-LIR) technique is introduced. Initially, the location of code bad smell
(i.e. weak gene) is identified where the software code to be refactored through the local search and fitness
calculation. Based on the fitness calculation, the weak and strong genes are identified. After that, refactoring
Technique is applied to perform rectification of code bad smell such as duplication, longer parameter list, and
temporary files in the identified location through the crossover and mutation operator. Therefore, the GSR-
LIR technique helps to preserve the applied refactoring behavior. Then, the result of the refactoring on
quality characteristics of the software is verified. Finally, consistency between the refactors’ program code
and other software artifacts are maintained in order to improve the quality of refactoring. Experimental
results shows that the proposed SRLIR technique achieves better performance in terms of refactoring
location identification accuracy, refactoring code consistency and refactoring quality compared to the state-
of-the-art works.
Keywords: Software refactoring, software quality maintenance, code smell detection, gene based refactoring,
Location Identification, fitness, Rectification, crossover and mutation.
1. INTRODUCTION
Software Engineering is the process of making to design, development, testing, implementation, and
maintenance of software code in an efficient manner. Software quality is a significant issue in the growth of
software application. There are several techniques applied to enhance the software quality. Refactoring is one of the
methods to detect the code smell thereby improving the software quality. Software Refactoring is a technique of
altering a software system but it not varies the external performance of the code. The application of refactoring
International Journal of Computer Science and Information Security (IJCSIS),
Vol. 15, No. 8, August 2017
367 https://sites.google.com/site/ijcsis/
ISSN 1947-5500

increases the code readability, maintainability, extensibility, Reduce complexity and software quality. The process
of the refactoring is suggested as shown in figure 1.
Figure 1 Process of software refactoring
As shown in figure 1, software refactoring process modifying the existing software code with no changes
occurred in external activities. Refactoring changes the irrelevant code of the software source code. The benefit of
Refactoring technique comprises better code readability and less complexity. This also increases the source-code
maintainability and generates a more significant internal architecture to improve extensibility. The software code
refactoring is also determined the computer bugs in the system by eliminating redundant levels of complexity.
Software Refactoring is generally activated by detecting a code smell (i.e. bad smell). In computer programming
code, refers to a few indications in the source code of a program that probably shows a deeper problem or
technically incorrect basis. The benefit of the software refactoring is the Maintainability of the software code
quality. It is easier to secure bugs since the source code is easy to read and its author is easily to seize. This is
achieved by reducing large routines into a set of individually summarizing, well-named, single-purpose techniques.
A monitor-based instant refactoring framework was introduced in [1] to help the developers for solving the
identified smells rapidly. However, it failed to handle more types of code smells and reduced the software quality.
A refactoring algorithm based on weighted clustering was introduced in [2] which obtain the optimal functionality
distribution from a system viewpoint. However, the software code quality maintenance was not improved at a
required level. An Aspect-oriented programming (AOP) approach was designed in [3] for handling the
maintainability of software. However, it provides criterion for restricted number of changes occurred. Dynamic and
Automatic Feedback-Based Threshold Adaptation technique was introduced in [4] for improving the recall while
containing the precision close to the target precision. However, it failed to perform more complex smell detection
algorithm. A B-Refactoring technique of test code was introduced in [5] for partitioning a test case into a number of
small test fragments. However, it does not investigate the reason of the various results due to the lack of historical
test data. In [6], the association among the code smells and preservation efforts were analyzed with several linear
regressions. However, it failed to maintain the consistency between program code and other software.A Parallel
Detect location of code
duplication (i.e. code smell)
Identification of refactoring
solution
Vol. 15, No. 8, Augus 2017
ISSN 1947-5500

Evolutionary algorithm (P-EA) was designed in [7] to provide more effective results on code-smells detection.
However, the efficiency of the algorithm and system performance was not improved. A class-level software
networks were introduced in [8] for improving the accuracy of bug prediction. But it failed for handling more open
source projects. In [9], a new technique was introduced to refactor the package construction of object oriented
software. However, it failed to develop a refactoring tool. An approach was introduced in [10] for automatically
evaluating clones without altering the performance of the program. However, it was not considered search-based
techniques to find exact location.Based on the above said limitations such as, lack of software quality,
maintainability, failed to handle several code smells and inconsistency. In order to address such kind of issues, Gene
based Software Refactoring Location Identification and Rectification (GSR-LIR) technique is introduced.
The contribution of the research work is explained as follows. Gene based Software Refactoring Location
Identification and Rectification (GSR-LIR) technique is introduced to improve the software quality maintenance. At
first, the gene population generation is carried out and identifies the location where the software code to be changed.
Secondly, refactoring technique is applied to rectify the code smell. This helps to improve the software quality and
reduces the inconsistency between the refactors program code and other software artifacts. The rest of the paper is
organized as follows: In Section 2, Gene based Software Refactoring Location Identification and Rectification
(GSRLIR) technique is explained with neat diagram. In Section 3 experimental settings is presented with detailed
analysis of results explained in Section 4. In Section 5, introduces the background and analysis the related works.
The conclusion of the research work is presented in section 6.
2. SOFTWARE REFACTORING
Software refactoring plays a significant role in order to improve software quality by altering the software
inner formation. The major issue in software refactoring is to identify the code smells that require refactoring.
However, the manual recognition methods are difficult to identify the code smells from large applications.
Therefore, an efficient refactoring technique is introduced to detect code smells automatically. The examples of the
different bad smells occurred while running the software code such as Code Duplication, long parameter list,
temporary field, etc. Therefore, the refactoring is used to improve the quality of software code reliability, and
maintainability.
2.1 Need for refactoring
Refactoring also increases software developer efficiency and increases code reuse continuous plan
allows including more flexibility into the design, by adding an initially simple design. The process of refactoring is
also used to contribute the developing states of the program code. Refactoring improves the plan of software
program quality. The software code which is generally obtains more refactored code to perform the similar effects;
therefore the Refactoring makes the code easy to understand. In most software development environments, someone
else force to read the code so it becomes easy for others to understand. Refactoring helps for determining the bug’s
present in the software program and also helps to run a program in quicker manner.
2.2 GENE BASED SOFTWARE REFACTORING
Vol. 15, No. 8, Augus 2017
ISSN 1947-5500

The software refactoring is performed in order to improve the software quality maintenance and reduce the
inconsistency while running the program code. The refactoring process is performed on the each part of the software
code. With this objective, Gene based Software Refactoring Location Identification and Rectification (GSR-LIR)
technique is introduced to improve software code quality maintenance. The following sections are illustrates the
GSR-LIR technique to improve the software quality rate.
Figure 2 Processing diagram of the Gene based software refactoring location identification and rectification
As shown in figure 2, processing diagram of the Gene based software refactoring location identification
and rectification is described. The proposed Gene based Software Refactoring Location Identification and
Rectification (GSR-LIR) technique performs two processing such as identifies the location of code smell where the
software code to be refactored through the local search and applied the refactoring technique to perform rectification
process. Initially, each software code is placed inside a gene to perform refactoring process. The refactoring process
determines which refactoring is needed in an identified location. Then, it ensures the applied refactoring preserve
behaviors. The result of refactoring on software quality characteristics is verified. Finally, preserves the consistency
between refactors program code and other software artifacts. The brief description of GSRLIR technique is
explained in the following sections.
2.2.1 Identify the location of software code smell
Initially, all the software codes are placed inside a gene to generate the initial population. Each member of
this population initiates a better solution based on fitness calculation. At first, the gene population is generated
Gene based software refactoring
Improve the software code quality
maintenance
Identify location of code smell
using local search and fitness
calculation
Perform rectification using
mutation operation
Source code
repository
Vol. 15, No. 8, Augus 2017
ISSN 1947-5500

arbitrarily. Then the Local search is applied in GSR-LIR technique to determine exact location of code bad smell
among a number of codes of lines in the source code. After that, every iteration the best individuals (i.e. gens) are
selected and the worst ones are altered with new ones generated from the fitness value. Then the local search finds
the exact location of code smell where the software code to be refactored. In general, every gene contains more than
one neighbor solution, the choice of which gene is selected based on the information about the neighborhood of the
existing one; hence the process is called as local search. The information about the neighborhood is identified
through the fitness calculation. The fitness is measured to select the high quality (i.e. best) and weaker (i.e. low
quality) in order to perform software refactoring. Therefore, the weaker gene is called as code smell. The gene
based technique determines the program code qualities of both of good and weak genes. Therefore, the fitness
function is measured as,
(1)
From (1), is the optimal weights of gene are determined hence the range is large as possible. From
the range, the middle point as a threshold to decides whether a gene is a weaker or strong quality.
(2)
From (2), If the quality of a gene is calculated with the optimal weights is less than the threshold
value, then the gene is judged to a weaker gene, and refactoring is suggested so that the gene is transformed using an
appropriate refactoring technique. Based on fitness calculation, the code smell is identified where the refactoring is
needed. In addition, the crossover process is carried out to generate the code of the first gene is compared with the
similar code of the second gene in order to produce the new offspring. Finally, the mutation process is used to alter
the duplication code in software program.
Selection
The selection operator in gene based software refactoring is performed for selecting the two parent genes from an
initial population along with their fitness function values which has the higher ability to produce a new generation
for performing the crossover operator.
Crossover
The crossover operation used chromosome of the different parent gene from individual generation to the
next generation. Let us consider one-point crossover that randomly generated. The first indicates that the elements of
two parents chromosomes are require to be exchanged, while residual chromosomes are unchanged. Let us consider
two parent gene (i.e. G1, G2) with chromosomes
and . Then the offspring is generated as follows,
Vol. 15, No. 8, Augus 2017
ISSN 1947-5500

Figure 3 One point crosses over
Figure 3 shows the one point crossover of generating the new population by recombination process. A
crossover point is chosen according to the selected chromosomes. Parts of the chromosomes are swapped after and
before the crossover point to generate the offspring by using parent chromosomes. The newly generated
chromosomes are used for performing the mutation operation where the code rectification is needed. The
rectification process is performed in next subsection.
2.2.2 Gene based Rectification using Mutation
A mutation is a process of performing the stable rectification in the program sequence that makes up a
gene. Once the cross over is completed, the gene is subjected to mutation operation alters the chromosomes to select
the higher fitness value. During the mutation, the refactoring techniques are applied in to rectify the code smell in
GSR-LIR technique. The various refactoring process are composing method, moving the feature between the
objects, organization of data and simplifying the conditional expression. The composing method includes extract
Method, Replace Temp with Query, Split Temporary Variable, Remove Assignments to Parameters. The moving
method consists of Move field, Extract Class and Inline Class. Then the data organization process includes replacing
the Code type with Class, replacing Array with Object, change Record with Data Class, and replacing record with
Data Class. The conditional expressions are eliminating Control Flag, Introduces Null Object and Introduces
Assertion. These refactoring methods are employed to rectify the code smell inside the source program code. Then
the GSRLIR technique ensures the applied refactoring preserves behavior.
The gene rectification operation aims to maintain the good chromosomes for altering the code smell. The
generated offspring are included into the population and the least chromosomes with low fitness (i.e. code) values
are removed from the population. Once the offspring populations are generated through the crossover operator, the
offspring is mutated with the probability (P). This helps to ensure genetic range from one generation to the next
ones. Then the random number (r) is generated and compared with the mutation probability (p). If the mutated
probability (p) is greater than the random number (r), then the mutation is performed otherwise the software code
remains unchanged.
Offspring
Parent 1 Parent 2
Vol. 15, No. 8, Augus 2017
ISSN 1947-5500

Figure 4 Mutation operation
Figure 4 shows the mutation process to rectify the code with the help of above said refactoring technique.
As shown in figure, the chromosome value of the gene is corrected with the exact chromosome of . Mutation
is in the population, a randomly interchanging the code for creating the new offspring to increase the fitness value. If
the new offspring is failed to satisfy the limitations like fitness threshold, it is removed and the iterations gets
repeated till it improve the quality characteristics of the software. The mutation operation avoids the local minimum
and it searches for the global optimal solution. As a result, the reliability between the refactors program code and
other software objects are preserved. The flow diagram of the gene based refactoring technique is obtained as
follows,
Figure 5 Flow Diagram of gene based software refactoring
Offspring
Start
Initialize the gene population
Calculate fitness of gene
Selection operator
Crossover operation (generate
new code)
Perform rectification
(Mutation operator)
Yes
No
Stop
Vol. 15, No. 8, Augus 2017
ISSN 1947-5500

Figure 5 shows the flow diagram of the GSRLIR technique performs efficient refactoring that detects the
location where the refactoring is needed and rectifies the code smell with appropriate refactoring technique. The
gene based software refactoring is performed effectively to alter the software code for maintaining the quality.
Initially, the gene population generation is carried out and then the fitness is measured based on assigning the weight
of each gene and their neighboring gene through the local search. If the measured weighting value is higher than the
threshold value, then the number of iteration has been stopped otherwise the best fitness value is computed through
the selection, crossover and mutation. The algorithmic description of the Gene based software refactoring location
identification and rectification technique is explained as follows,
Input: No. of genes (i.e. software code), Two parent gene with chromosomes
and
Output : Improved refactoring quality
Step 1: Begin
Step 2: Initialize the gene population
Step 3: Calculate fitness of each individual gene using (2)
Step 4: if ( then
Step 5: Number of iteration has been completed
Step 6: Else
Step 7: Select the low quality gene
Step 8: Perform crossover generates new chromosome
Step 9: Rectify the refactoring code using mutation
Step 7: Terminate the algorithm until the specified condition is satisfied or else go to
Step 3.
Step 8: End
Figure 6 Gene based software refactoring location identification and rectification algorithm
Figure 6 shows the Gene based software refactoring location identification and rectification algorithm to
improve the software code quality maintenance. Generate the initial gene population to identify the best gene and
weaker gene through the local search of the fitness value calculation. The fitness is measured based on the
weighting function of minimum good code quality and maximum bad code quality. Based on fitness calculation, the
strong gene and weaker gene are separated with the specified threshold value. If the fitness is greater than the
threshold value, the iteration gets stopped otherwise perform selection process. Based on selection, the weaker gene
(i.e. code smell) is identified and it’s rectified through the refactoring technique to improve the quality of
refactoring. Quality of refactoring is verified through the crossover to generate the new chromosome. Finally, the
mutation is performed where the code rectification is performed. This process is repeated until the entire gene is
verified. This helps to improve the consistency among the refactors software program code and other software
objects.
Vol. 15, No. 8, Augus 2017
ISSN 1947-5500

3. EXPERIMENTAL EVALUATION
The proposed Gene based Software Refactoring Location Identification and Rectification (GSRLIR)
technique is experimented using JAVA programming code with SchoolMate dataset. The SchoolMate dataset is the
open-source programs. The SchoolMate consists of brief solution related to elementary, middle and high schools. It
processed with four domains, namely, administration, teachers, students and parents, where the administration
domain manages both the classes and users of the SchoolMate whereas the teachers’ domain manages the details
about assignments and grades. Information regarding students’ domain is accessed with information is also be
verified by the parents’ domain. The GSR-LIR technique experimented against the existing monitor-based instant
refactoring framework [1] and weighted clustering algorithm [2]. The experiment is conducted on the factors such as
refactoring location identification accuracy, refactoring code consistency and refactoring quality.
4. RESULTS AND DISCUSSION
Analysis of Gene based Software Refactoring Location Identification and Rectification (GS-RLIR)
technique is compared with existing monitor-based instant refactoring framework [1] and weighted clustering
algorithm [2]. The analysis is carried out on the factors such as refactoring location identification accuracy,
refactoring code consistency and refactoring quality. The performance is evaluated according to the following
metrics with the help of table and graph values.
4.1 Impact of Refactoring Code location identification accuracy
Refactoring Code location identification accuracy is used to identify the location of code smell from the
source code where the refactoring is applied. It is defined as the difference between number of source code lines and
the incorrect code lines are identified in the source program. The mathematical formula for accuracy is defined as
follows,
(3)
From (3), where is the Refactoring Code Location Identification Accuracy which is measured in
terms of percentage (%).
Vol. 15, No. 8, Augus 2017
ISSN 1947-5500

Table 1 Tabulation for Refactoring location identification accuracy
Source code (KB) Refactoring Code location identification accuracy (%)
GSRLIR Monitor-based instant
refactoring framework
Weighted clustering
algorithm
2 71.68 60.45 50.45
4 75.44 65.78 55.61
6 78.10 68.46 60.14
8 82.36 72.15 66.45
10 86.10 75.89 70.42
12 90.46 82.23 73.65
14 92.75 85.98 75.54
16 94.58 88.24 78.65
18 95.34 90.25 79.10
20 96.12 91.65 83.58
Table 1 show the Refactoring Code location identification accuracy based on the size of source code (KB).
While increasing code size, the Refactoring Code location identification accuracy gets increased in all the methods
such as GSRLIR technique, Monitor-based instant refactoring framework [1] and weighted clustering algorithm [2].
The input as a source code and the size is 2KB which contains 10 lines of code. From the source code lines,
numbers of incorrect code lines location are detected for applying the refactoring. The location detection accuracy is
increased using GSR-LIR technique than the other existing methods.
Figure 7 Measure of Refactoring Code location identification accuracy
Vol. 15, No. 8, Augus 2017
ISSN 1947-5500

Figure 7 illustrates the experimental results of the Refactoring Code location identification accuracy for
each source code size. The source code is varied in the range of 2KB to 20KB for experimental purpose. From the
figure, while increasing the size of source code, comparatively accuracy gets improved using GSR-LIR technique.
This is because, gene based refactoring technique is applied to identify the location where the refactoring is applied
to improve the refactoring quality. In GSR-LIR technique, initially gene population is generated randomly. Then the
stronger gene and weaker gene and their location are identified through the local search of the fitness value
measurement. Based on fitness threshold value, the weaker gene location is identified to apply the refactoring
technique. The local search in GSR-LIR technique identifies the neighboring solution to detect the location of code
smell. This challenge in software code is rectified the code smell for maintaining the consistency. Therefore,
GSRLIR technique improves Refactoring Code location identification accuracy. The percentage of accuracy is
obtained 11% and 26% using GSRLIR technique compared to existing Monitor-based instant refactoring framework
[1] and weighted clustering algorithm [2] respectively.
4.2 Impact of refactoring code consistency
Refactoring code consistency is measured based on the amount of time taken to rectify the code without
changing the external behaviors. The mathematical formula for Refactoring code consistency is measured as
follows.
(4)
From (4), where denotes refactoring code consistency, is the number of incorrect code lines and
time for rectifying the one code by applying the software refactoring technique. It is measured in terms of
millisecond (ms). Lower the software code rectification time, more efficient the method is said to be.
Table 2 Tabulation for Refactoring code consistency
Source code (MB) Refactoring code consistency (ms)
GSR-LIR Monitor-based instant
Weighted clustering
algorithm
2 10.32 20.15 28.72
4 16.24 30.42 35.14
6 22.10 42.47 49.18
8 36.56 54.39 68.32
10 44.89 63.56 85.56
12 53.38 79.61 97.17
14 67.13 87.46 106.45
16 83.14 107.83 118.54
18 96.73 117.34 127.63
20 112.45 128.41 143.34
Vol. 15, No. 8, Augus 2017
ISSN 1947-5500

Table 2 shows the results analysis of refactoring code consistency using GSR-LIR technique and existing
Monitor-based instant refactoring framework [1] and weighted clustering algorithm [2] are presented. When the
software code size is increased, the statistical analysis implies that there occurs a stable increase in the time taken for
rectifying the software code which is technically incorrect. The code rectification time gets reduced and increased
the consistency using GSR-LIR technique than the existing methods.
Figure 8 Measure of Refactoring Code consistency
Figure 8 show the measure of Refactoring Code consistency in terms of time with respect to size of the
source code from 2KB to 20KB. While increasing the source code, the time gets gradually increased. But
comparatively, the GSRLIR technique reduces the rectification time than the existing methods [1] [2]. This is
because; the proposed GSRLIR technique manages the consistency between refactors program code and other
software objects. The rectification process is carried out in GSRLIR technique using gene based approach. Initially,
the weaker gene (i.e. software code) is identified through the fitness calculation. Then, the rectification is performed
through the application of refactoring method. Through the crossover operation two parent’s chromosomes are
exchanged to generate the newly generated chromosomes. Then the code duplication is rectified through the newly
generated chromosomes with the help of mutation operation. The mutation is performed for rectifying the
technically incorrect code without changing the external behavior. This process is repeated until the entire software
code is verified to improve the quality. Therefore, the minimum time is used to improve the consistency between the
refactors program code and other software objects. The incorrect code rectification time is reduced by 31% and 42%
compared to existing Monitor-based instant refactoring framework [1] and weighted clustering algorithm [2]
respectively.
Vol. 15, No. 8, Augus 2017
ISSN 1947-5500

4.3 Impact of refactoring quality
Refactoring quality is defined as the ratio of difference between the number of code lines and incorrect
codes lines that are correctly refactored to the total number of code lines in the source code (KB). The formula for
refactoring quality is expressed as,
(5)
From (5), is the Refactoring quality and it is measured in terms of percentage (%).
Table 3 Tabulation for Refactoring quality
Source code (KB) Refactoring quality (%)
GSR-LIR Monitor-based instant
Weighted clustering
algorithm
2 69.45 59.53 51.36
4 73.10 63.45 54.63
6 78.65 65.87 57.68
8 82.12 67.48 61.69
10 85.45 69.12 63.89
12 86.75 73.65 68.12
14 88.36 76.98 70.13
16 90.45 80.65 72.63
18 92.47 83.20 78.46
20 94.85 86.36 80.64
Table 3 describes the refactoring quality with respect to size of source code in terms of KB. From the
source code file, the numbers of identified incorrect code lines are accurately refactored through the software
refactoring technique. The proposed gene based software refactoring technique improves the refactoring quality than
the existing Monitor-based instant refactoring framework [1] and weighted clustering algorithm [2].
Vol. 15, No. 8, Augus 2017
ISSN 1947-5500

Figure 9 Measure of refactoring quality
Figure 9 depicts the impact of refactoring quality versus source code size using three methods. As shown in
figure, the proposed GSRLIR technique provides improved performance result of refactoring quality than the two
existing methods [1][2]. While increasing the size of the source code program, the refactoring quality gets increased
using all three methods. This is due to application of gene based refactoring location identification and rectification
technique. Initially, each software code lines are placed inside the gene. After that, the gene which has the strong
quality and low quality is separated through the fitness function of local search for identifying the location to
perform refactoring. Certain fitness threshold is fixed to identify the correct code and code smell from the source
code. The weight of the gene is measured to identify the technically incorrect code. From that, the weaker genes are
selected to perform efficient refactoring in order to perform rectification process through the mutation operation. In
Mutation process, a randomly swapping the code creates the new offspring to increase the fitness value. This helps
to improve the effect of the refactoring on quality uniqueness of the software. The quality of refactoring improves
the code readability, maintainability, extensibility and complexity. Therefore, the GSRLIR technique improves
refactoring quality by 9%, 18% when compared existing Monitor-based instant refactoring framework [1] and
weighted clustering algorithm [2] respectively.
Therefore, Gene based Software Refactoring Location Identification and Rectification (GSR-LIR)
technique improves the code smell location detection accuracy and reduces the rectification time to maintain the
software code quality.
5. RELATED WORKS
Software Refactoring [11] process used for improving the quality and permits developers to restore code
without handling existing source code and starting again. Duplicate fragment of the code was detected in [12] using
clone detection algorithm designed for UML domain approaches. However, the weighing similarity effects with the
Vol. 15, No. 8, Augus 2017
ISSN 1947-5500

size of the code fragments were not improved the accuracy of clone detection. This problem is addressed in gene
based refactoring technique through the fitness measure.
The program dependence graph (PDG) was introduced in [13] to detect the code clones but failed to expand
tools for detecting exact bugs in programs. The GSR-LIR technique effectively identifies the code smell (i.e. weaker
gene). A traditional tree-based clone detection algorithm was designed in [14] by using more information regarding
the variable slices. However, it failed to analyze the feasibility of making automated clone deletion. Therefore, the
code duplication is identified through the local search of neighboring solution. An efficient clone detection was
presented in [15] through three various tools and examine the impact of clone refactoring on different software
quality parameters. However, the refactoring of clones failed to eliminate the new code smells and reduces the
software quality. The gene based refactoring technique identifies the more code smell and improves the quality.
An Optimal Batched refactoring plan Execution methodologY (OBEY) was introduced in [16] to attain
best batched refactoring plan execution. However, the OBEY does not improve the effects of refactoring plans for
avoiding improper refactoring decisions. The gene based software refactoring technique performs gene rectification
process and interchanging the code exclusive of affecting the external behavior. In [17], identifies the class
attributes that express the information about the maintenance of that class to facilitate and develops a collection of
metrics. However, the quality and maintainability of the software metrics was not considered. The proposed gene
based refactoring technique improves the software quality code maintenance through the improvement of refactoring
quality analysis.
A Methodbook technique was developed in [18] to detect refactoring ability and eliminate the bad smell
from source code. But this technique was not used better refactoring tools. This problem is addressed in GSR-LIR
technique to improve quality of refactoring. The association between complexity of software and maintenance costs
was introduced in [19]. But it failed to reduce the costs of software maintenance. This problem is addressed in
GSR-LIR technique to improve the quality of software code maintenance. A consistency-maintenance operation was
defined in [20] that automatically forecast a code clone through copy-and-paste operations. However it stills hard to
accurately forecast the consistency-maintenance. The GSR-LIR technique improves the consistency between the
refactors’ program code and other software objects to improve the quality. As a result, an efficient Gene based
Software Refactoring Location Identification and Rectification (GSR-LIR) technique improves their performance
result and improves the software code quality maintenance.
6. CONCLUSION
Software code quality maintenance is a complex problem in software engineering to improve the
performance of the framework. Therefore, an efficient Gene based Software Refactoring Location Identification and
Rectification (GSR-LIR) technique is developed for software code quality maintenance. Initially, the location of
code smell is identified through the fitness measurement through the optimal weight value of each gene. With the
optimal weight value, the gene location is identified with threshold value and it selects which gene needs to be
refactored. Based on the fitness value, the low quality gene is rectified through software refactoring technique
Vol. 15, No. 8, Augus 2017
ISSN 1947-5500

without changing the external behavior through the crossover and mutation operator. Therefore, code duplication,
long parameter list, and temporary files are rectified to improve the software quality. This GSRLIR technique helps
to guarantees the refactoring preserves behavior. Finally, the refactoring process improves consistency and
improves the software quality code maintenance. Experimental evaluation is conducted with the open-source
program as schoolmate dataset to measure the effectiveness of the proposed (GSR-LIR) technique in terms of
Refactoring Code location identification accuracy, Refactoring Code consistency and Refactoring quality with
respect to differing software project code size and source lines of code. The results analysis shows that GSR-LIR
technique improves Refactoring Code location identification accuracy, Refactoring quality and Refactoring Code
consistency with minimum time than the state-of-art methods.
REFERENCES
[1] Hui Liu , Xue Guo, Weizhong Shao, “Monitor-Based Instant Software Refactoring”, IEEE Transactions on Software Engineering, Volume
39, Issue 8, 2013, Pages 1112 – 1126
[2] Ying Wang, Hai Yu, Zhi-liang Zhu, Wei Zhang ,Yu-li Zhao, “Automatic Software Refactoring via Weighted Clustering in Method-level
Networks”, IEEE Transactions on Software Engineering, Volume PP, Issue 99, Pages 1-35
[3] Kagiso Mguni and Yirsaw Ayalew, “An Assessment of Maintainability of an Aspect-Oriented System”, ISRN Software Engineering,
Hindawi Publishing Corporation, Volume 2013, December 2012, pages 1-11
[4] Hui Liu, Qiurong Liu, Zhendong Niu , Yang Liu, “Dynamic and Automatic Feedback-Based Threshold Adaptation for Code Smell
Detection”, IEEE Transactions on Software Engineering Volume 42, Issue 6, 2016, Pages 544 - 558
[5] Jifeng Xuan, Benoit Cornu, Matias Martinez, Benoit Baudry, Lionel Seinturier, Martin Monperrus, “B-Refactoring: Automatic test code
refactoring to improve dynamic analysis”, Information and Software Technology, Elsevier, Volume 76 , 2016, Pages 65–80
[6] Dag I.K. Sjoberg, Aiko Yamashita, Bente C.D. Anda , Audris Mockus, Tore Dyb, “Quantifying the Effect of Code Smells on Maintenance
Effort”, IEEE Transactions on Software Engineering , Volume 39, Issue 8, 2013, Pages 1144 - 1156
[7] Gajjala Madhavi and K.Suresh Kumar Reddy, “Code Smells Detection by using Enterprise Complement Search-based Software Engineering
Approach”, International Journal of Emerging Technology in Computer Science & Electronics (IJETCSE), Volume 17, Issue 1, 2015, Pages 56-
53
[8] Peng He, Bing Li, Yutao Ma, and Lulu He, “Using Software Dependency to Bug Prediction”, Mathematical Problems in Engineering,
Hindawi Publishing Corporation, Volume 2013, August 2013,Pages 1-12
[9] Wei-Feng Pan, Bo JiangBing Li, “Refactoring Software Packages via Community Detection in Complex Software Networks”, International
Journal of Automation and Computing, Springer, Volume 10, Issue 2, 2013, Pages 157–166
[10] Nikolaos Tsantalis, Davood Mazinanian, and Giri Panamoottil Krishnan, “Assessing the Refactorability of Software Clones”, IEEE
Transactions On Software Engineering, Volume 41, Issue 11, 2015, Pages 1055-1090
[11] Anshu Rani and Harpreet Kaur, “Refactoring Methods and Tools”, International Journal of Advanced Research in Computer Science and
Software Engineering, Volume 2, Issue 12, December 2012, Pages 256-260
[12] Harald Störrle, “Towards clone detection in UML domain models”, Software & Systems Modeling, Springer, Volume 12, Issue 2, 2013,
Pages 307–329
Vol. 15, No. 8, Augus 2017
ISSN 1947-5500

[13] S. Sargsyan, Sh. Kurmangaleev, A. Belevantsev, and A. Avetisyan, “Scalable and Accurate Detection of Code Clones”, Programming and
Computer Software, Volume 42, Issue 1, 2016, Pages 27–33.
[14] M. Akhin and V. Itsykson, “Tree Slicing: Finding Intertwined and Gapped Clones in One Simple Step, Automatic Control and Computer
Sciences, Volume 47, Issue 7, 2013, Pages 427–432
[15] Francesca Arcelli Fontana, Marco Zanoni, Andrea Ranchetti, and Davide Ranchetti, “Software Clone Detection and Refactoring”, ISRN
Software Engineering, Hindawi Publishing Corporation, Volume 2013, January 2013, Pages 1-8
[16] Hewijin Christine Jiau, Lee Wei Mar, and Jinghong Cox Chen, “OBEY: Optimal Batched Refactoring Plan Execution for Class
Responsibility Redistribution”, IEEE Transactions on Software Engineering, Volume 39, Issue 9, 2013, Pages 1245-1263
[17] John Michura, Miriam A. M. Capretz, and Shuying Wang, “Extension of Object-Oriented Metrics Suite for Software Maintenance”, ISRN
Software Engineering, Hindawi Publishing Corporation, Volume 2013, January 2013, Pages 1-14
[18] Gabriele Bavota, Rocco Oliveto, Malcom Gethers, Denys Poshyvanyk, and Andrea De Lucia, “Methodbook: Recommending Move Method
Refactorings via Relational Topic Models”, IEEE Transactions on Software Engineering, Volume 40, Issue 7, 2014, Pages 671-694
[19] Edward E. Ogheneovo, “On the Relationship between Software Complexity and Maintenance Costs”, Journal of Computer and
Communications, Volume 2, 2014, Pages 1-16
[20] Xiaoyin Wang, Yingnong Dang, Lu Zhang, Dongmei Zhang, Erica Lan, and Hong Mei, “Predicting Consistency-Maintenance Requirement
of Code Clones at Copy-and-Paste Time”, IEEE Transactions on Software Engineering, Volume 40, Issue 8, 2014, Pages 773-794
Vol. 15, No. 8, Augus 2017
ISSN 1947-5500

Gene Based Software Refactoring Location Identification and Rectification For Software Code Quality Maintenance

Recommended

Recommended

More Related Content

What's hot

What's hot (18)

Similar to Gene Based Software Refactoring Location Identification and Rectification For Software Code Quality Maintenance

Similar to Gene Based Software Refactoring Location Identification and Rectification For Software Code Quality Maintenance (20)

Recently uploaded

Recently uploaded (20)

Gene Based Software Refactoring Location Identification and Rectification For Software Code Quality Maintenance