Request your demo of the Sigrid® | Software Assurance Platform:
Green IT helps reduce the IT industry’s growing carbon emissions driven by inefficient software development practices. While generally, Green IT is perceived as practices that all pertain to making hardware and infrastructure more sustainable, the software side is often overlooked.
Inefficient coding and decisions—made without sustainability in mind—can lead to software systems that consume more energy than necessary at every stage of the software development life cycle, for example: development, maintenance, and deployment.
This is where green software development is vital. In this article, we’ve identified some key practices that will help reduce the carbon footprint of software. These development practices include developing a green coding framework, adopting tools to measure your software’s energy efficiency as well as a wide range of green coding practices, optimizing software for existing hardware to reduce the need for frequent updates and associated e-waste, and choosing regions with low-carbon energy grids for computing and software operations.
Next to this, the crucial role of IT leadership in making software development as sustainable as possible is two-fold; First as change agents, forging the organization’s path toward a greener future, and as educators, raising awareness, changing mindsets, and retraining developers in the art of green software engineering.
Until recently, it was a common (and understandable) misconception that the IT industry’s growing carbon footprint was mostly generated by the hardware it employed. After all, hardware requires the extraction of precious materials and consumption of energy to be manufactured in the first place, before spending its lifespan using electricity to operate.
However, the build quality of the software you develop will have an influence on how much energy each program takes to run. While it’s certainly not the only factor, it can be quite impactful.
Moreover, for hardware to operate more efficiently—and thus sustainably—the software which runs it needs to be fit for purpose first.
So, instead of pointing towards hardware and infrastructure as the major source of IT’s carbon emissions, we should also closely examine the software and software engineering practices.
Poor coding standards, messy system architecture, and the unnecessary use of energy-draining coding structures—such as looping and conditional statements—are key contributors. These practices not only lead to software that consumes excessive energy when running but also demand even more energy to maintain, fix, adapt and scale.
The ICT industry is projected to account for 14% of global carbon emissions by 2040. This is unsustainable both environmentally and financially, as we will discuss later.
As you will already be aware, there is a growing concern around carbon emissions in IT, with industry leaders looking for a solution to the problem of exponential growth in their organizations’ carbon footprints. Green IT may well be that solution.
Green IT also plays a crucial role in ensuring regulatory compliance, such as with the Corporate Sustainability Reporting Directive (CSRD), which will soon require companies to report on their environmental risks and impacts. The alignment of software development with sustainability goals will help organizations not only meet these regulations but also reduce their carbon footprints.
It covers a variety of different practices, from reducing e-waste by recycling hardware to procuring more efficient hardware. But by far the most crucial role in green IT is to be played by your software engineers.
The core tenet of Green IT, as Software Improvement Group’s CEO Luc Brandts argues, is code efficiency: “When you want to do things on sustainability in software, it is really about looking at the code.”
This article is designed to demonstrate clearly why software engineering is key to reducing your enterprise’s carbon footprint, provide you with practical steps you can take, and share handy tools so that your IT department can begin its green IT journey today.
So how exactly can software—a non-tangible, digital application or program comprising lines of code and little else—emit carbon? Let’s answer this question by first refreshing our minds on the definition of a carbon footprint.
National Geographic defines a carbon footprint as “the sum total of all the greenhouse gas emissions that had to take place in order for a product to be produced or for an activity to take place.”
With this quote in mind, we may begin to see how it could apply to software—in particular, software development. After all, as one of Google’s developers so succinctly puts it: “running any kind of computer workload requires energy in the form of electricity. And this energy often comes from sources that release CO2.”
Fair enough, you may be thinking, this all makes logical sense so far. And yet, if it’s the hardware consuming energy to run the software, not vice versa, then why do we claim that software is a problem in this carbon equation?
Let’s look at the 3 main software factors contributing to your carbon footprint.
From the very start of the software development lifecycle (SDLC), the decisions your engineers make and the quality of code they write will significantly impact the carbon-intensity of the final software.
Choosing a coding language, for instance, can have a massive effect on just how much energy is consumed during the coding process and later, when other devices run the finished application. Studies have shown, for example, that coding with Python can consume around 45-75 times as much energy as a much more energy-efficient language like C, C++, or Java.
AI development and training—an increasingly intrinsic part of the IT industry—is another highly carbon-intensive aspect of software development. For example, to train just one neural network model today pumps into our atmosphere as much carbon, or CO2, as five cars would in their lifetimes.
Further down the SDLC, the maintenance of your software also becomes a carbon problem. When code is written inefficiently in the beginning—or legacy systems are still in use long after they should have been upgraded or replaced—something called ‘technical debt’ quickly builds up.
Technical debt takes the form of high labor costs and lower employee satisfaction, to name but two factors, and can demand up to 40% of your entire IT budget just paying engineers to spend their time digging through spaghetti code and inefficient phrasing to fix bugs, change or scale programs, and maintain an application’s up-time.
Lastly, we discovered that inefficiencies introduced during design and maintenance phases increase your software’s carbon footprint when deployed.
When code is written inefficiently—using energy-intensive language, unnecessarily heavy loops, large conditional statements or floating-point operations, or employing excessive memory accesses—it demands a whole lot more energy to run on an end-user’s device, compared to code written with sustainability and efficiency as core drivers.
One of the major challenges of implementing green IT into your software development practice is convincing your engineers—who are already experts in their field—that for the good of the planet, and your company’s sustainability score, they may need to change the way they work.
And yet, there are in fact plenty of reasons why a software designer or architect should want to adopt green software engineering best practices.
Let’s take a look at four core benefits of green coding.
1. Environmental impact
Software—not just hardware—can be highly energy consumptive. This consumption can be greatly reduced through green IT practices which in turn help reduce the ICT industry’s impact on the environment, helping to protect and heal both the world and the people in it. In essence, “embracing green software development practices allows developers to make a significant contribution to environmental sustainability.”
2. Cost savings
Not only does more efficient software engineering help the environment, but it also helps engineers save their companies some cash. In fact, when green IT is successfully employed, software development can save an organization anywhere from 17-90% of their current energy costs—i.e., on their utility bills.
3. Greater opportunity for innovation
When code bases are made cleaner and more efficient, they require engineers to spend less time maintaining them, in turn freeing those employees to focus on greater innovation in software design and development. In a word, green IT can help unleash greater creativity and, as a result, improve your engineers’ job satisfaction levels.
4. Performance
Perhaps most importantly, one of the key indirect benefits of adopting Green IT and sustainable software development practices is that it often leads to the creation of higher-quality software. By prioritizing efficiency in coding and system design, the resulting software typically performs better, runs faster, and is more reliable. This focus on sustainability not only reduces energy consumption but also leaves engineers with a product they can take greater pride in.
Now that we’ve discussed the role software engineering plays in producing carbon emissions—and why it’s important to care about this—let’s outline some of the practices you can employ to reduce your carbon footprint through green software engineering.
As Abhijit Sunil, Senior Analys at Forrester said, “measuring the impact of your efforts is important. because if you can measure it, you can improve it”. There are many green IT tools and frameworks you can employ to help you measure and reduce the carbon footprint of your software. To make it easier for you to navigate, we’ve made a list.
SCI gives actionable approaches for engineers and developers to measure the carbon impacts of their systems. Currently, SCI is being adopted into the ISO/IEC standard 21031:2024 to encourage more of these actions to be taken during the design, development, and maintenance of software applications.
SCER provides comparable sustainability scores for software with the same functionality as that which you’re developing.
The GSMM focuses on how to help you measure and report on your green IT practices.
The “Green Software” (GREENSOFT) reference model offers a holistic lifestyle model for software, sustainability criteria and metrics of software products, a “Green Software Engineering” procedure model, recommendations for actions and for the tools to use to make your software and development practices more sustainable.
With energy measurement tools, frameworks and standards at your disposal, you are now able to better assess the elements of your software development strategy which produce unsustainable amounts of greenhouse gas emissions.
As argued earlier, a major factor in IT’s carbon footprint is to do with inefficient and poor coding practices. Let’s look at some key energy-efficient coding practices you can employ to reduce energy consumption and reduce your carbon footprint.
Assess the APIs (Application Programming Interfaces) at your disposal in terms of energy consumption and work with those which are most efficient and eco-friendly.
Developers should be challenging the assumptions around end-user expectations regarding media, and reduce the file sizes of their images, videos, and text during design for the sake of reducing energy consumption.
For example, the Java Collections Framework contains many data structures, like List and Set. However, it’s a common assumption among engineers that the List data structure is the most efficient, leading them to overlook that this is not the case for all use cases.
It’s crucial to recognize this, as overlooking it can result in inefficiencies rather than efficiency gains.
That is not to say that it isn’t possible.
IEEE published a paper titled “Recommending Energy-Efficient Java Collections,” which concluded that it is feasible to provide energy-saving recommendations for alternative collection implementations to be used in different parts of the system. By using a tool called CT+, they evaluated a high-end server, a notebook, and three mobile devices, and managed to achieve up to a 17.34% reduction in energy consumption simply by replacing collection implementations.
It is good to remember that data structures have different operations, such as storing, retrieving, and removing.
Each data structure has different characteristics for each of these operations, some are more efficient with storing, but not with lookup, others are efficient with lookup, but don’t provide storing capabilities. By carefully considering the efficiency of different data structures in your systems, you can adopt more sustainable choices and implement changes where it can benefit you most.
Use efficient coding techniques to make your code base as clean, concise, and accessible as possible.
Monitoring your power consumption in real time with dynamic code analysis is the best way for your engineers to understand the gaps and correlations between their design choices and software’s carbon footprint.
We stated before that software plays a bigger role in ICT’s carbon footprint than does hardware. The reason for this is that software is often developed in ways that encourage continual hardware upgrades, leading to the disposal of ‘outdated’ devices.
However, optimizing software for existing devices reduces e-waste and lowers our carbon footprint.
Considering that the average lifespan, or turnover, for hardware is between just 1-5 years, we can also further reduce our e-waste output by writing software to prolong the lifespan of compatible devices.
Lastly, it should be noted that the need for new, upgraded hardware can be reduced—or at the least, slowed down—by efficiently managing workloads through intelligent orchestration, to avoid a build-up of “embedded carbon”. Developers implement instrumentation during development and deployment to assess the software’s carbon footprint, whilst simultaneously measuring real-time energy consumption of the application, in order to identify modules which can be improved for greater energy efficiency.
Different regions of your country, and different countries around the world, deliver grid electricity with differing degrees of carbon intensity. For example, compare Texas’s dependency on natural gas to Sweden’s preference for solar.
If you have the opportunity to choose between different regions in which to run your development practices (e.g., you own an independent software development firm with the ability to set-up anywhere in the world), then you can greatly reduce the carbon emissions of your SDLC energy consumption by establishing yourself in a region with low-carbon-intensity electricity supply.
As IT leaders, your role in promoting sustainability within your software development practices is crucial. The importance of this role can be broken down into two key parts.
Writing energy-efficient software is not easy and requires a shift in mindset from your team of software engineers and architects. It is the job of developers to act as change agents, encouraging sustainability within your organization in order to deliver greater efficiency not just for the sake of the environment, but also for the continued growth and success of the software development industry—preparing it for a future which requires sustainability to be baked into the core of the SDLC.
One of the key challenges of green IT is addressing a lack of understanding and awareness about software’s carbon footprint among developers, coupled with their possible skepticism. IT leaders must educate developers on the impact of their work on carbon emissions and how to make sustainable choices.
Training will also prove key to the future of green software engineering, as will the ability to demonstrate the mutually beneficial relationship between the environment, software performance, project costs and job satisfaction which sustainable IT fosters.
Inefficiencies in coding and system architecture are responsible for a percentage of the ICT industry’s carbon footprint, because the quality of your software directly impacts the amount of energy it requires to be developed, maintained, and deployed.
Creating highly maintainable code leads to a reduction in maintenance effort. Second, it is easier to integrate green coding patterns into an existing system with a well-structured code base and software architecture.
As such, software engineers are set to play a critical role in reducing your organization’s carbon footprint through the adoption of energy-efficient development practices.
With the need for, and applications of, software increasing year-on-year—as our society continues to delve deeper into the Digital Age—organizations must now prioritize sustainable software engineering, whilst developers and IT leaders should focus on adopting green IT and advocating for even more sustainable development solutions in future.
Learn more about green IT and how it could benefit your organization by exploring the Software Improvement Group blog.
Author:
Head of Innovation
We'll keep you posted on the latest news, events, and publications.
