The adoption of refactoring techniques for continuous integration received much less attention from the research community comparing to root-canal refactoring to fix the quality issues in the whole system. Several recent empirical studies show that developers, in practice, are applying refactoring incrementally when they are fixing bugs or adding new features. There is an urgent need for refactoring tools that can support continuous integration and some recent development processes such as DevOps that are based on rapid releases. Furthermore, several studies show that manual refactoring is expensive and existing automated refactoring tools are challenging to configure and integrate into the development pipelines with significant disruption cost. In this paper, we propose, for the first time, an intelligent software refactoring bot, called RefBot. Integrated into the version control system (e.g. GitHub), our bot continuously monitors the software repository, and it is triggered by any “open” or “merge” action on pull requests. The bot analyzes the files changed during that pull request to identify refactoring opportunities using a set of quality attributes then it will find the best sequence of refactorings to fix the quality issues if any. The bot recommends all these refactorings through an automatically generated pull-request. The developer can review the recommendations and their impacts in a detailed report and select the code changes that he wants to keep or ignore. After this review, the developer can close and approve the merge of the bot’s pull request. We quantitatively and qualitatively evaluated the performance and effectiveness of RefBot by a survey conducted with experienced developers who used the bot on both open source and industry projects.

Successful software products evolve through a process of continual change. However, this process may weaken the design of the software and make it unnecessarily complex, leading to significantly reduced productivity and increased fault-proneness. Refactoring improves the software design while preserving overall functionality and behavior, and is an important technique in managing the growing complexity of software systems. Most of the existing work on software refactoring uses either an entirely manual or a fully automated approach. Manual refactoring is time-consuming, error-prone and unsuitable for large-scale, radical refactoring. On the other hand, fully automated refactoring yields a static list of refactorings which, when applied, leads to a new and often hard to comprehend design. Furthermore, it is difficult to merge these refactorings with other changes performed in parallel by developers. In this paper, we propose a refactoring recommendation approach that dynamically adapts and interactively suggests refactorings to developers and takes their feedback into consideration. Our approach uses NSGA-II to find a set of good refactoring solutions that improve software quality while minimizing the deviation from the initial design. These refactoring solutions are then analyzed to extract interesting common features between them such as the frequently occurring refactorings in the best non-dominated solutions. Based on this analysis, the refactorings are ranked and suggested to the developer in an interactive fashion as a sequence of transformations. The developer can approve, modify or reject each of the recommended refactorings, and this feedback is then used to update the proposed rankings of recommended refactorings. After a number of introduced code changes and interactions with the developer, the interactive NSGA-II algorithm is executed again on the new modified system to repair the set of refactoring solutions based on the new changes and the feedback received from the developer. We evaluated our approach on a set of eight open source systems and two industrial projects provided by an industrial partner. Statistical analysis of our experiments shows that our dynamic interactive refactoring approach performed significantly better than four existing search-based refactoring techniques and one fully-automated refactoring tool not based on heuristic search.

Refactoring studies either aggregated quality metrics to evaluate possible code changes or treated them separately to find trade-offs. For the first category of work, it is challenging to define upfront the weights for the quality objectives since developers are not able to express them upfront. For the second category of work, the number of possible trade-offs between quality objectives is large which makes developers reluctant to look at many refactoring solutions. In this paper, we propose, for the first time, a way to convert multi-objective search into a mono-objective one after interacting with the developer to identify a good refactoring solution based on his preferences. The first step consists of using a multi-objective search to generate different possible refactoring strategies by finding a trade-off between several conflicting quality attributes. Then, an unsupervised learning algorithm clusters the different trade-off solutions, called the Pareto front, to guide the developers in selecting their region of interests and to reduce the number of refactoring options to explore. Finally, the extracted preferences from the developer are used to transform the multi-objective search into a mono-objective one by taking the preferred cluster of the Pareto front as the initial population for the mono-objective search and generating an evaluation function based on the weights that are automatically computed from the position of the cluster in the Pareto front. Thus, the developer will just interact with only one refactoring solution generated by the mono-objective search. We selected 32 participants to manually evaluate the effectiveness of our tool on 7 open source projects and one industrial project. The results show that the recommended refactorings are more accurate than the current state of the art.

Today, maintenance and evolution are critical software development activities that might comprise up to 80% of the overall cost and effort throughout a software’s lifetime [13]. Maintenance costs often can be inflated through poor software design called code smells and defined as design situations that adversely affect the software maintenance [12]. These code smells, such as Blob and functional decomposition, decrease the cohesion in the classes and increase coupling leading to a poor modularity. In fact, code smells appear, in general, extensively in systems where requirements change quickly over time due to the customers need since developers have limited time to release a new version of the system [27][28]. Thus, the quality of variability-intensive system is lower than regular systems with lower requirements or code changes, so it is important to consider automated tools for the correction of code smells in similar situations. One of the widely used techniques to fix code smells is refactoring defined as the process of changing a software system in such a way that it does not alter the external behavior of the code yet improves its internal structure [20]. An example of refactoring is moving methods between classes to increase cohesion and reduce coupling. Some work proposes “standard” refactoring solutions that can be applied by hand for each kind of code smell (eg Blobs, large methods, etc.). However, there is no consensus to define these standard solutions since the same type of code smell can be fixed by many alternatives. In fact, developers can propose different refactoring solutions to fix the same code fragment and these solutions …

Face recognition using thermal images has received high attention by researchers in recent years. Since skin temperature can be visualized using thermographic cameras, a unique imprint can be achieved for thermal image of a person’s face. In this study, we have investigated the effect of using different partitioning strategies of face imprint on thermal face recognition. First, we have proposed a simple and reliable approach for face extraction using ellipse mask. Then, the face imprint has been attained using anisotropic diffusion filter and morphological processing. The face imprint is related to distribution of blood vessels under the face skin. In the next step, the face imprint has been partitioned using different strategies including rectangular, circular and polar approaches. The number of minutiae point in each partition has been computed. Finally, a SVM classifier based on one-against-one approach has been …