As a general rule the delivery rate of all commissioned software is pretty low when we take into account the total amount that are commissioned versus the amount that are actually accepted and used by a somebody. Over that when it comes to business software in particular the average life is about 5 years before it becomes obsolete – dead! When software is created one usually ends up with big hulking monoliths that have very tightly coupled components, thus, making them difficult to deploy. To ease that developers add layer after layer of complexity until we are left with a system that is too big and too complicated to actually function.
One can say that most of the work created a software engineer’s lifetime is sooner or later non-existent. The reason behind this is that historically most software has been so difficult to change that it is easier to kill it and start anew.
This killing of software systems is a strange thing considering that the world we live in is made up of extremely complex systems that thrive and function for years. The biggest example of that is the human body.
With everything one puts the human body through it should not survive for years at end and yet it does. Why is that? The answer is that it is self-regulating. The human body constantly discards cells that are irrelevant, old or have lived out their lifetime and replaces them with newer cells.
If we want software that lasts for our entire life times then it needs to be easy to change and should weather the changing technological environment. For this we need our software to mimic the human body!
In order to do so we would have to discard parts that are becoming obsolete and replace them with newer and better parts. For us to be able to do this with a systems architecture we would need Micro Services.
Because these parts would have to be small, very loosely couples components that can easy to discard because they aren’t coupled and replace because they are not long and complicated.
For these parts to be high performing the best route to go would be for them to be written in the language that works best for each individual part. Additionally it is difficult to tightly couple components that are written in different languages.
This decoupling of components leads to failure. The good thing about knowing that you have increased chances of failing is that you are prepared to fail, thus making it easier to recover and create better codes.
These are all factors that Micro Services make possible. Micro services make it possible for us to create code small enough that we can remove it without fear and systems that can live forever.
Written By: Meghna Verma