Mel Cinneide

Interest in the energy consumption of software has grown with rising energy costs and greater environmental awareness. Many approaches to research in this area have been proposed, from the examination of hardware and compiler optimizations to platform specific software modifications. However, the impact of general software design on energy efficiency remains unclear. The goal of this research is to summarize the findings of studies that empirically examine the impact of design patterns, code smells, and refactorings (which we collectively describe as design elements) on energy consumption. Our secondary goal is to provide an overview of the impact of these aspects of software design on energy performance and discuss the current state of the art. We present a systematic literature review (SLR) of papers that examine the impact of the aforementioned design elements on energy consumption. We perform a search through four major databases, a manual search through publications of eight conferences and five journals from 2010 through 2023, in addition to snowballing. We extract relevant data from the literature and present an overview of each experiment's setup, the data reported, and results for each design element studied. Beginning with a set of 8684 papers, we select 24 that include studies of these design elements. Overall, they provide data on 22 design patterns, 17 code smells, and 31 refactorings. Many studies are preliminary in nature, and contradictory findings are frequent. We present three main findings: (i) a wide array of design patterns, code smells, and refactorings have been examined from an energy performance perspective; (ii) many of these studies are preliminary in nature and indicate the need for further research; (iii) there has been little growth recently in publications empirically examining these aspects of software design.

Software metrics are measurable characteristics of software. They are commonly used to quantify qualitative aspects of software like internal quality and complexity. Energy-aware developers and researchers alike would benefit from the discovery of a static metric that correlates well with energy performance, as static metrics can be calculated at compile time rather than requiring run-time energy profiling. However, no static metric has been found that is a reliable indicator of energy performance to date. This work proposes a novel approach that employs run-time profiles to appropriately weight compile-time metrics in an effort to more accurately predict the energy performance of the software at run-time. Preliminary investigations using data from previous works highlight the potential for mean weighted coupling between objects (CBO) to be an indicator of energy performance. A subsequent experiment was conducted with a small application which was automatically refactored to reduce CBO, and consequently mean weighted CBO. Results are in line with the finding that increasing mean weighted CBO reduces energy consumption.

Design patterns are applied frequently during software evolution in order to make the software more flexible and amenable to extension. One little-studied aspect of design patterns is their propensity to increase run-time energy consumption due to the indirection and additional structure they introduce. In this paper we study the impact of the Visitor pattern on energy efficiency. The Visitor pattern separates an algorithm from the objects it acts upon and improves maintainability by placing each algorithm within a single visitor class. This is at the cost of increased indirection due to the double dispatch required when the algorithm is invoked. We experimentally investigate the energy impact of varying the implementation of this pattern, and of removing the pattern entirely from software written in Java and C++. In our results we observe energy consumption reductions greater than 7% in a Java-based textbook example when the pattern is implemented using reflective dispatch, and reductions of over 10% when experimenting with an open source Java project, JavaParser. The complete removal of the pattern yields more complex results, with little impact in the textbook example but reductions of over 7% in the JavaParser study. To explore the generalisability of our findings, we subsequently apply the same transformations to the C++ based CppParser. Total pattern removal here sees energy consumption reductions of over 66% while the reflective dispatch approach increases energy consumption by up to 2012%. Our results highlight the energy savings that can be achieved when the Visitor pattern is removed both in Java and C++ implementations, and also show that some language specific features can allow for further energy savings when the implementation of the pattern is varied.

Refactoring is performed to improve software quality while leaving the behaviour of the software unchanged. Identifying refactorings applied to a software system is an important activity that leads to a better understanding of the evolution of the software system, and several techniques have been proposed and implemented to address this issue. The vast majority of existing refactoring detection techniques are language-specific, including the accepted state of the art, RMiner, which is exclusively Java-based. Although impressive performance has been achieved to date, there is scope for improvement in refactoring detection and such improvement would enhance both refactoring research and practice. In this paper, we propose a novel, language-neutral technique to identify refactorings in commit histories. Our approach is motivated by a desire to explore the use of string alignment algorithms in refactoring detection, and to determine if such approaches are competitive with the state of the art. The proposed approach has been implemented in a tool called RefDetect, evaluated, and compared with the current state-of-the-art refactoring detection tool: RMiner. In experiments we applied RefDetect to 514 commits of 185 Java applications containing 5,058 true refactoring instances, achieving an f-score slightly better than that achieved by RMiner (87.3% vs. 86%). RefDetect clearly outperformed RMiner in method and class based refactorings, achieving f-scores respectively of 87.7% vs. 81.7% for method-level refactorings and 92.1% vs. 86.9% for class-level refactorings. To demonstrate the language-independence of RefDetect, we conducted a further study with four C++ applications, achieving high values for both precision (96.1%) and recall (94.1%). The achieved results indicate that RefDetect performs better than the current state of the art in refactoring detection and is demonstrably capable of handling different programming languages.

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.

TextabstractRefactoring has become a standard technique for software developers to use when trying to improve or evolve the design of a program. It is a key component of Agile methods, the most popular family of software development methodologies in industrial practice. Refactoring has also been the subject of much attention from researchers and many practitioner textbooks have been written on the topic. It would be natural to assume then that the benefits of refactoring would be easy agree upon, and easy to measure. In this position paper we review a selection of the empirical studies that have attempted to measure the benefits of refactoring and find the situation to be quite unclear. The evidence suggests that what motivates developers to refactor, and what benefits accrue from refactoring, are open issues that require further research