GreenSoftwareLab: Towards an Engineering Discipline for Green Software


The current widespread use of non­wired but powerful computing devices, such as, for example, smartphones, laptops, etc., is changing the way both computer manufacturers and software engineers develop their products. In fact, computer/software performance (ie, execution time), which was the primary goal in the last century, is no longer the only and main concern. Energy consumption is becoming an increasing bottleneck for both hardware and software systems. Recently, hardware manufacturers andresearchers have developed techniques to reduce energy consumption mainly focused on developing and optimizing their hardware. This is the natural approach to reduce energy consumption since it is the hardware which literally consumes energy. However, very much like how a driver operating a car can heavily influence its fuel consumption, the software which operates such hardware can drastically influence its energy consumption too! Recent research in software engineering has defined powerful techniques to improve software developers productivity by providing, for example, advanced type and modular systems, integrating developing environments (IDE), testing and debugging frameworks and tools, etc. Moreover, compiler construction techniques were developed to improve the execution time of our software, namely by using partial and/or runtime compilation, advanced garbage collectors, parallel execution, etc. All these engineering techniques and tools aim at helping software developers quickly define correct programs with optimal runtime. Unfortunately, none of these techniques nor tools have been adapted to support greenware software development. Indeed, there is no software engineering discipline providing techniques and tools to help software developers to analyze, understand and optimize the energy consumption of their software! As a consequence, if a developer notices that his/her software is responsible for a large battery drain, he/she gets no support from the language/compiler he/she is using. In this project, we aim to study, develop, and apply methods to analyze “energy leaks” in software source code. Thus, the focus of the project is to reason about energy consumption at the software level. In this context, we define energy leaks as an abnormal and excessive consumption of energy by a software system. We will start the project by adapting well known techniques for fault localization and program debugging in software source code, to locate energy­leaks in software and to relate such leaks to the software source code. Software source code metrics and a catalog of program smells will be adapted to the energy­aware realm. Using these techniques, we will identify what programming practices, design patterns, and other factors contribute to high energy consumption. Being able to locate such energy leaks in the developer’s code, we will construct both a catalog of software energy metrics and a catalog of red smells (i.e., energy inefficient smells in source code). These techniques are the main building blocks for the next phase: providing a set of source code refactorings and supporting tools that help developers in green decision making and in optimizing the code. A source code refactor is a source­to­source transformation that does not change the semantic behaviour of a program. Our energy­aware catalog of refactorings, named “green refactorings”, will be used to improve software energy consumption. First, red smells are marked in the source code, and one or more green refactoring will be suggested so that developers make their software greener. We envision an Integrated Energy­aware Development Environment (IEDE) in which the refactorings are automatically applied, or semi­automatically applied with the developer’s guidance. To validate our techniques we will develop libraries and tools to support green decision making such as generic and reusable libraries implementing the catalog of energy metrics, red smells and green refactorings. To analyze and locate energy leaks, an energy profiler, a red smell detector, and other energy monitorization tools, will be developed. To optimize energy leaks, a framework implementing the red smells/green refactorings will be defined as IDE plugins (Eclipse, etc.). Such a framework will localize where in the source code is a red smell, while also providing the programmer the relevant information to show where and what is making his/her code energy inefficient, methods/alternatives, and automatically optimize the energy and refactor the code. All of this will allow programmers to finally become energy­-aware while programming and consider this aspect of their code, and with the appropriate tools, can finally have ways to support green decision making. Finally, we will validate our methods, tools, and techniques with real case studies with our industrial partners through benchmarks, and professional programmers through empirical studies.


Funded by

Fundação para a Ciência e Tecnologia

Total budget

155 000,00 €

Local budget

38 500,00 €


Software Analysis, Software Manipulation, Green Software Computing

Start Date


Conference Articles


(2 publications)


(3 publications)