The Carbon-Free Pass Is Over: A Fundamental Turn Toward Sustainability in Software

In 2005, Herb Sutter ( 微软 ) declared that the free lunch was over. The era of expecting general-purpose computing to get faster every year without any effort from developers was ending. Instead, developers would need to work harder to write software that could take advantage of multi-core and multi-threaded architectures. Read more The Free Lunch Is Over.

Fast forward to today, and we’re facing a new challenge. The carbon-free pass is over. We can no longer ignore the environmental impact of our software. We need to think about how our software uses resources and how it can be more efficient. This is the era of carbon-effective software.

Why is Carbon-Effective Software Important?

The IT sector is responsible for roughly the same carbon emissions as the aviation industry. And as the digital economy grows, so does its carbon footprint. We can’t afford to ignore this. We need to find ways to reduce the carbon emissions of our software.

We should treat carbon effectiveness like performance and security. If we do not design our software being carbon effective, it has a defect and we need to fix this defect.

How Do We Create Carbon-Effective Software?

Creating carbon-effective software requires a shift in how we think about software development. Here are some principles:

1. Efficiency: Write code that does more with less. This means optimizing algorithms for performance, reducing unnecessary computation, reducing network traffic, and using resources more efficiently. Use programming languages and frameworks being designed for efficiency.
2. Dematerialization: Move to the cloud. Cloud providers can achieve economies of scale that individual companies can’t, leading to more efficient use of resources.
3. Utilization: Make use of orchestration services of virtual machines and containers. This allows better utilization of hardware resources, reducing the need for manually ramping up virtual and physical machines.
4. Power management: Use power management features in hardware, operating systems, and runtime environments. This can significantly reduce the power consumption of idle or under-utilized resources.
5. Green UX: Design user experiences that encourage energy-saving behavior. This could be as simple as a power-saving mode in an app, or as complex as a system-wide initiative to reduce screen time. This creates awareness on the consumer side.

The Taxonomy of Principles, Patterns and Practices

The taxonomy of principles, patterns, and practices is a way of organizing and understanding key concepts in various fields, such as software development, design, management, and more. Let's break down each term:

1. Principles: Principles are fundamental truths or guidelines that inform decision-making and behavior. They are the foundation upon which practices and patterns are built.In software development, the SOLID principles (Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion) guide the design of object-oriented systems.
2. Patterns: Patterns are recurring solutions to common problems. They provide a template for solving specific issues and are based on best practices and successful strategies. In software design, the Observer pattern defines a one-to-many dependency between objects, where one object (the subject) maintains a list of its dependents (observers) that are notified of any changes in the subject's state.
3. Practices: Practices are specific activities or methods that are recommended or proven to achieve certain outcomes. They are often derived from principles and may involve the application of patterns.In agile software development, daily stand-up meetings, sprint planning, and continuous integration are common practices that support principles such as collaboration, adaptability, and delivering value iteratively.

When considering the taxonomy of principles, patterns, and practices, it's important to recognize their interconnected nature:

• Principles inform Patterns: Principles provide the foundational concepts that lead to the creation of design patterns. For example, the SOLID principles guide the creation of object-oriented design patterns.
• Patterns embody Principles: Patterns are practical implementations of principles. They provide a way to apply abstract principles to concrete problems.
• Practices instantiate Patterns: Practices involve the application of patterns in specific contexts. They represent the actual implementation of patterns and principles in real-world scenarios.

Understanding and applying this taxonomy is crucial for professionals in various fields, as it helps in creating robust and maintainable systems, efficient problem-solving, and the development of successful strategies and methodologies. Whether in software engineering, architecture, management, or other disciplines, a solid grasp of principles, patterns, and practices contributes to better decision-making and more effective problem-solving.

What is Carbon-Effective Software?

Carbon-effective software is software that is designed with the environment in mind. It’s about making software that uses less energy, produces less heat, and ultimately emits less carbon. It’s about thinking about the entire lifecycle of the software, from development to deployment to maintenance, and making choices that reduce its environmental impact.

The Green Software Foundation already showed some love to the taxonomy of principles, patterns, and practices: Learn Green Software.

The Road Ahead

The shift to carbon-effective software won’t be easy. It will require new tools, new skills, and a new mindset. But it’s a challenge we must face. The carbon-free pass is over, but the work is just beginning.

A decade ago, I enjoyed two workshops being held by Scott Meyers about C++ best practices. He did this highly technical deep-dive in perfect German. His answer to our question why he taught himself German was:

"C++ and German are highly complex languages, and I like to master them both." - Scott Meyers

There is no excuse for being lazy and staying with legacy software architectures, nor deploying scripting languages, which are mainly designed for prototyping, and bloated web frameworks into production. Let us roll up our sleeves and get to it.

Patterns are domain, and practices are vendor specific. I commit to the domain of spatial data science and ArcGIS technology from Esri . What is your commitment?