-The deeper problem in the source code are the bad smells that indicates something is wrong and if they are not detected timely, then they lead towards the complete deterioration of the working software causing major financial and productivity loss. Refactoring helps in removing these bad smells by improving internal quality attributes of the software without affecting its external behaviour. However refactoring needs to be applied in a controlled manner. In this study an approach has been propose for determining an optimal refactoring sequence that will maximize the source-code maintainability using greedy algorithm. The proposed approach selects the most optimum sequence at every step-in hope of finding the global optimum solution. We conduct an empirical analysis on four open-source software and select those classes that have bad smells greater than or equal to four. Further filtration is done by selecting those classes from the group that have high value of source code lines. We demonstrate the effectiveness of our approach using concrete examples of the experimental dataset and presenting summary results. Index Terms-Empirical Software Engineering, Software Quality, Refactoring, Greedy Algorithm, Software Maintainability
Fowler [
Although software consists of both functional as well as
non-functional attributes but refactoring helps in improving
its non-functional attribute like improving code readability,
reducing complexity etc. It helps in transforming the source
code that no longer contains code smell. For example, if
long methods are present in source code than it results in
poor understanding and increasing complexity. Therefore, it
leads towards the need of applying refactoring techniques
so that these problems get removed early. Techniques like
Extract Method are used to extract some lines of code from
the long method to make it short and precise so that it
can be easily understood. Refactoring helps in improving the
software maintainability. It needs to be applied in a short
cycle and in a controlled manner so that it does not result
in any negative impact on the quality and functionality of the
software. Although these small cycles or transformation may
not give extraordinary results but the cumulative effect will
be very significant for the overall performance of the software
[
Recently, several researchers are conducting study on
finding the correct or best sequence for refactoring techniques
so that software maintainability value gets enhanced [
A. Ghannem et al. [
We download source-code dataset from sourceforge and bad
smells are identified with the help of plug-ins like JDeodorant
[
Greedy algorithm is an algorithmic paradigm that always
makes choices that look best at that moment [
In this study, greedy algorithm is used to find the refactoring sequence for the datasets used. At every step, we move forward in the tree formed (refer to Figure 1 and 2), greedy algorithm takes decisions which are best at that moment and move forward and at the end it gives the refactoring sequence so that the overall maintainability can be maximized. Greedy algorithm plays an integral part in this study after the formation of the trees.
As it can be seen in Table I, various types of bad smells are identified in the source code and their removal requires different types of refactoring techniques. Table I displays bad smells found in eight classes of the Jtds project. Table I presents the number of bad smells, list of bad smells and the lines of code in the Class containing the bad smell. We observe that there are classes with number of bad smells more than 5 which clearly shows the need of refactoring and also identifying a correct order of refactoring. Figure 3 shows the step-by-step procedure and result (as a worked out example and illustration) of applying the proposed approach on Classes belonging to the JTDS project. As shown in Figure 3, we perform grouping based on the number of bad smells, select classes based on the highest LOC value and then apply the refactoring sequence.
Different refactoring techniques can be applied to the same part of the code which will then convert the original code to different versions depending on which refactoring technique is applied. Sometimes, combination of refactoring techniques are applied to the code to see whether it result in the better version of the original code or not. These scenarios need to be kept in mind in forming the trees for different software. Trees represents structured object that needs to be explored by human beings from root node to the leaf. Trees are faster to search therefore are more convenient and efficient to use. In this study, trees are formed after applying refactoring to the original code in two ways that are discussed below.
In one-ary analysis (refer to Figure 5), trees are formed by applying various refactoring techniques on a same potion of the code. It results in different versions of the original code and hence will help in finding the best quality version among all. It needs to be kept in mind that the changed version should be an improved version of the original source code. After applying the refactoring techniques, this analysis will give the top most refactoring technique and hence will be very useful for the software developers to apply the best refactoring in the future during maintenance phase.
As shown in Figure 4, four refactoring techniques like Extract Method (EM), Push Up (PU), Push Down (PD) and Move Method (MM) have been applied to the initial original code to get four changed versions of the software. The CC denotes the changed code and is collaborated along with the refactoring technique in a node of a tree. This notation becomes easy to understand and implement. Software developers will have four alternative paths and only one can be selected based on the improvement of the quality of the code with respect to maintainability. Hence, three refactoring techniques need to be eliminated and is done by considering the maintainability value of the software after applying it.
The two-ary trees (refer to Figure 5) are formed after combining refactoring techniques on the source code so that percentage of improvement of quality gets increased. It is important to enhance the quality of the software by applying refactoring in different combinations because refactoring is itself expensive that can make the situation even more worse, therefore controlled mechanism has to be kept in mind. As shown in Figure 3, Figure 4 and 5, the original code gets converted to the changed code CC1 by applying Extract method class. Afterwards push up refactoring technique is applied to get CC2 and so on. Different refactoring techniques are applied one after the other on the same portion of the code to get final changed version CC4. These refactoring techniques are applied in accordance to the presence of bad smell in code. Therefore at the end, refactoring sequence is found out to be EM ! PU ! PD ! MM but consideration should be given to the fact that after applying this refactoring technique sequence in order, the value of software maintainability needs to be maximized then only there will be a gain in terms of time as well as budget.
It is not always possible to apply refactoring techniques one after the other. There may be situations where some will be eligible to apply and some are not. In this manner, two-ary trees are formed. As take another example where original code contains four types of bad smells and two types of refactoring techniques combinations can be applied on the same portion. Therefore, the two-ary tree for the same will be similar to Figure 5. As it can be seen, extract method along with push up can be used as well as move method and push down techniques can also be used. Here, there exist two refactoring sequences EM ! PU and MM ! PD. Hence, it depends on the value of software maintainability of the changed code version that will decide which combination improves the quality of the software more.
The order in which refactoring is applied initially depends on two factors, the presence of a particular bad smell that will help in judging the software developer which particular technique should be used in removing that smell and priority of the refactoring techniques, that is, Refactoring Priority, RP which is calculated with the help of maintainability values and number of classes in which a particular refactoring technique is applied. Initially, individual refactoring technique say X is applied and value of maintainability, M is observed. After
TABLE VIII
FOUR CLASSES FROM JTDS DATASET SELECTED AS ILLUSTRATIVE EXAMPLE TO DEMONSTRATE REFACTORING SEQUENCE DETERMINATION
ALGORITHM Sequence Tdscore.java (7 smells) Jtdsstatement.java (6 smells) Support.java (5 smells) Jtdsdatabasemetadata.java (4 smells)
CBO MM ! EMRC
MM ! RC EC ! RE EM ! RC dividing M value with the number of classes in which X is applied, priority of X technique can be determined. In a similar way, priority values of all the refactoring technique used in this study is found out and highest priority is given to that refactoring technique that will have minimum value. It will help in selecting refactoring technique during formation of trees. (1) RP [X] =
In Equation 1, SO represents the sum obtained and N CR represents the number of classes in which refactoring is applied.
Various developers and programmers across the globe are voluntarily creating open source software and uploading it on the platform where they are easily accessible to anybody for their use. With the help of this software, it becomes easy for researchers to generalize the results and work on these datasets so that a trend can be set up. Keeping this in mind, in this study four datasets have been downloaded from sourceforge.net. These datasets are chosen as their size varies from small to medium sized and hence will help in generalizing the result. The description of the dataset used has been provided below.
JTDS1 - It is an open source jdbc 3.0 type 4 driver for Microsoft SQL Server. It is currently the fastest production ready JDBC driver for SQL server. It consists of 64 classes.
JChess2 - It is a java based chess game project that requires two players playing on local computer or via network connection. It consists of 69 classes.
OrDrumbox3 - It is an open source audio sequencer and software drum machine that is used to compose the bass line for completing the song. It consists of 217 classes. ArtOfIllusion4 - It consists of 739 classes and is a fully featured 3D modeling, rendering and animation studio. It consists of subdivision surface based modeling tools, graphical language for designing etc.
For each metric of open source dataset which have been used in this study their descriptive statistics are collected like maximum value, minimum value, standard deviation etc but due to lack of space, tables are not included in this study. Therefore, following interpretations are added about descriptive statistics to give a little understanding about these datasets.
The maximum value of AHF is nearly 100 in each datasets indicating hidden property of attributes. The standard deviation value of WMC is high in AOI and Jtds datasets indicating high faults. The standard deviation value of LCOM is highest in Jtds datasets hence cohesion among methods is minimum. The maximum value of RFC is highest for dataset AOI and Jtds which tells that these two datasets are more prone to faults. The mean value of CBO is highest in case of ArtOfIllusion dataset which implies that classes are highly complex therefore lacks understandability. The standard deviation value of Ocavg is highest in case of Jtds dataset which indicates complexity. The standard deviation value of MHF is highest in case of ArtOfIllusion dataset which shows that methods have little functionality as compared to other dataset’s method.
In order to demonstrate the workings of the proposed approach, one of the dataset results has been shown step by step for the clear and better understanding of the algorithm proposed to obtain refactoring sequence. Dataset jtds consist of 64 classes in which eight classes have been considered as severe as they contain bad smells greater than 4 and are shown in Table I along with their LOC values. Priority values of the refactoring techniques have been found out with the help of Equation 1 and accordingly rank is assigned as shown in Table II to each refactoring technique used to remove the bad smells present in the classes of the dataset. These ranks will help in selecting refactoring techniques for the formation of the trees. Classes are selected on the basis of highest LOC value as higher LOC value will lead towards more confusion and complexities and hence need to be focused urgently; therefore four classes have been selected as shown in Table VIII for finding out the correct refactoring sequence for maximizing maintainability. Table VIII also contains the type of refactoring techniques required in a particular class according to the different bad smells. The formation of the tree is done according to the analysis discussed in the Section III-A and III-B. Refactoring techniques are selected on the basis rank assigned to them. Figure 5 describes the formation of the 1-ary tree for jtdsDatabaseMetaData.java and 2-ary tree for tdscore.java respectively. Table III to Table VII [different types] contains the change in value of metrics after applying refactoring techniques so that sum can be calculated for all the metrics that will help in relating it with the maintainability of the class. Tables III to Table VII are created with the help of trees formed in analysis step. With the help of trees levels, each table is formed. If results for tdscore.java are taken into consideration then it can be seen from Table III that it is formed by after the application of R2 and R4 refactoring techniques. Afterwards, minimum value is selected among all the rows calculation by keeping in mind the inverse relation between the software metrics and maintainability.
In Table IV to VII, again the combinations of refactoring techniques are applied but this time only that part of the tree is taken forward that gets selected in table. For example, in table MM, EM combination has minimum sum of metric value therefore it is taken forward and only that part of the tree is selected and considered in future. Remaining part of the tree gets rejected and will not take part in obtaining the refactoring sequence as greedy algorithm is used that selects the optimal solution at each step. Therefore, at the end refactoring sequence for tdscore.java is found to be MM ! EM ! RC as this combination has minimum value of sum of metrics which results in maximum maintainability. In a similar way, refactoring sequence of other three classes is found out and is shown in Tables IV to VII and Table IX. The proposed algorithm is applied to other datasets as well and their respective sequences for severe classes are obtained as shown in Tables IV, VII and IX.
As it can be seen from the Table XI, the number of god class and long method type of bad smells are high in all the datasets which indicates the maximum use of extract class and extract method refactoring technique throughout the case study in removing them and hence it will be a part of refactoring sequence in most of the cases. Hence, it can be concluded that most common refactoring sequence will EC-EM. There are classes in the datasets in which bad smells are not present and hence no change is required. It can be seen from Table X, for instance consider dataset Artofillusion, 194 classes out of 739 classes will remain unchanged which indicates that no effort will be wasted in improving these classes and software maintenance team can focus on other classes with high number of bad smells so that refactoring sequence can be figure out by applying proposed algorithm. It can also be observed from Table XI that over logging type of bad smell is not present in any dataset and hence sprout class refactoring technique will never be a part of refactoring sequence.
classes. The proposed approach is based on identifying bad smells for each class in the object-oriented software system (number of bad smells and types of smell) and grouping the classes based on the number of bad smells. The approach consists of computing object-oriented metrics and applying a greedy algorithms involving the formation of 1-ary and 2-ary trees searching for a sequence that improves the metric values and improves the maintainability of the system. We conduct experiments on four open-source Java projects to demonstrate the effectiveness of our approach. We conduct a series of experiments and explain the workings of the approach step-bystep using worked-out examples and finally present summary results for all the classes for all the four projects. We present descriptive statistics of the final results which shows that the proposed approach meets its desired objectives.