Normally, as Developers, most of us have started to expect that an architecture will be available, and we will simply implement, or execute the system based on the guidelines, or constraints provided in the architecture.
This is true for most junior developers, but as we start to get more and more experience, by working on different initiatives across different companies, our companies start expecting more from us.
They want us to have an architectural mindset as well, to think holistically about the entire system, and not just about the single piece of function, or program, or component that we are working on, as an individual.
This is where Architecture comes into place.
Architecture can be defined as many different things, starting from complex ISO definitions, etc, but I like to define it very simply - " An architecture of a system is anything related to that system that has an impact if I need to change the system in future, in any way or shape or fashion".
Architecture also comes in different forms, like Software Architecture ( most common ), System Architecture, Integration Architecture, Infrastructure Architecture, Security Architecture, and so on.
I am sure most of you are aware of what Architecture is in some way or form, and are also aware of the different common forms of architecture that are widely used in enterprises today. However, here I want to introduce you to something that is more recent, and not that widespread as of now, but is gaining a lot of traction in the recent past - "Sustainable Architectures"
What is Sustainability?
As per Wikipedia, Sustainability is defined as "Sustainability is a societal goal that broadly aims for humans to safely co-exist on planet Earth over a long time."
But, here my purpose in this article is to explain everything as simply as possible, so I will try to refrain from research lingo, or standard definitions, and try to explain in the context of a developer, or an architect.
The overarching goal of Sustainability is to make the world better from an environment perspective, reduce waste, reduce pollution, increase conservation, reduce our dependency on fossil fuels, etc.
If we have more sustainability in all our initiatives, then the world eventually becomes a better place for our future generations, as we are able to reduce global warming, stop flooding, epidemics and so on.
But, how or why does it relate to us? How can we help?
This is the first question that came to my mind when I was introduced to this topic 6 months to 1 year back.
Normally, as a member of the development team, or engineering community, or as architect, we do not have to think about sustainability when we designing/implementing systems/architectures.
But, those days are gone now. Atleast as an architect, or even as a developer, we are supposed to be aware of how our work has a direct impact on the overall sustainability targets of my enterprise.
Again, I am oversimplifying for the purpose of this introductor article. Let's take an example :
Say, I have 2 Cloud providers X and Y, who provide infrastructure and hosting services. Let's say X uses coal powered datacenters, whereas Y uses wind powered datacenters.
Since, wind is renewable energy, and coal is a fossil fuel, wind produces less emission than coal, and as such using wind over coal is better from an environment, or pollution, or sustainability perspective.
In this case, it could be that X provides some better offerings/price margins than Y, still, as an enterprise you might have to choose Y over X, to meet the overall sustainability targets of your enterprise.
So, in all aspects of technology, starting from choice of Cloud Service providers ( AWS, Azure, GCP, AliCloud, etc ) to choice of programming languages (C#, Java, etc ), there are impacts of our decision on the overall sustainability of our enterprise.
So, what are Sustainable Architectures?
To put very simply, I like to define this as architecture ( be it software, integration or infrastructure ) where sustainability is also considered one of the NFR(s) - Non Functional Requirements.
Normally, in architectural assignments we choose our standard NFR(s) which we want our design, or solution to adhere to/respect like Availability, Reliability, Maintainability, Elasticity, Resiliency, etc.
But, going forward as architects, we should put a similar focus if not more on the sustainability aspect of our solution.
We should be aware of the possible impacts of our technology choices on the overall sustainability of the solution, and how we can reduce the carbon impact ( or similar metrics ) of our solution, by making wiser/better architectural decisions, with regards to sustainability.
As developers, do I need to do something also?
What we do as a developer has a direct impact on the sustainability of the solution as well. Let's take an example.
Say we have two developers A and B working on the same functional requirement.
A writes a very efficient code that runs in a VM in 1 hour, whereas B writes a less efficient code that performs the same work ( in the same VM ) in 10 hours.
In this case, for simplicity sake, we can consider that B's code is polluting our environment 10 times more than A's code.
But, you might be wondering how can my code pollute the environment, I am just writing a few lines of code in my IDE, on my favorite langugage like C#.
This is because all code needs processing power/compute to run, and these compute pools run on physical nodes, which in turn are powered by datacenters, these datacenters use electricity, coal, energy, etc to run.
So, the more a datacenter has to run, the more pollution it creates, which in turn makes the sustainability targets hard to achieve.
So, what are some concrete steps we can take?
Sustainability architecture is a very fast topic, and has a lot of in-depth content to it.
In this blog, which is just an introductory one, I wanted to introduce this concept holistically, so that you are aware of this.
Over time, we will deep-dive into different aspects of the same, of how we can control our carbon emissions by making smart, sustainable architectures.
So, let me mention here a few aspects, which I hope will excite you enough to wait for the rest of the articles in this series :
Migration to Cloud
Most of the major CSP(s)/hyperscalers are taking a lot of initiative to reduce the overall carbon emission, and meet their sustainability targets, with regards to their datacenters.
So, migrating to the Cloud from on-prem datacenters could be one way to reduce the overall emission of your solution.
Choose datacenters/CSP regions which are more eco-friendly
Not all datacenters, or all regions are made equally, some are still powered by coal stations, while others have moved to green energy sources. Take this into account as well when designing/architecting solutions.
Reduce/eliminate low-utilization compute pools
Low utilization implies that for the same coal being burnt, or for the same pollution getting generated, I am doing less business work, which should be avoided as much as possible. There are different ways to optimize this, which can help both from a financial/cost perspective, as well as sustainability targets.
Move to modern architectures which support sustainable ecosystems
For example, rather than keeping a VM on for days, if we can move to an event-driven architecture, where my compute pool ( AWS Lambda for example ) is only running when the request comes in, can reduce the overall emission of my solution.
.....And there are many other nuances that I will explain in the other articles of this series.
Conclusion
Sustainable architectures, and designing sustainable, efficient IT systems will lead the next decade, for sure.
As technologists, we should be aware of this as well, at least from a strategic perspective, so that we can take them into account in our day-to-day work.
Hope this session made you curious enough to check out some of the other articles in this series.
Reference links
- https://www.youtube.com/watch?v=3-Zq2W1-odU
- https://www.youtube.com/watch?v=8-VD0vvIJlo&t=4s