I have been coding for more than 25 years and used more than 18
different programming languages (and the framework each is good and strong at)
spanning every programming style from simple scripting, procedural to objected
oriented to dynamic, functional (more attractive to Software Engineering
community these days). Let me confess, every time I switched to new language or
style I always felt “Oh, hope I also had that”. Trust me no language is
complete; no style is perfect. So only way to feast your programming appetite
is try something different which gives the flexibility. I honestly think,
MicroServices style of application is the one that gives the needed
flexibility.
It is not said and done. We need a more pragmatic answer to the
question “Why it is fun?” In my experience, the biggest challenge in designing
& building software systems is that of the identification of all the bit
and pieces of the jigsaw puzzle. As we know, it is never easy to identify the
position of any piece when we start. We get more clarity as we start putting
the bits together. But still we do the mistake of attempting to design a
software system upfront in a big piece (most of the core and add additional
functionality to the core which is not expandable incurring more and more technical
debt). Ideally what we need is a model or mechanism through which we can
identify and build smaller components and put them together with great ease.
This is why we use lean agile process. But what is the use of an agile process
when our engineering approach is monolithic. This is where Micro-services approach rocks.
Micro-services are small building blocks of the application which
can be put together to build the complete application functionality. Keep
building smaller components and weave them together. Need a new functionality?
Build and deploy a new micro-service. This simple change in perception of
developing application provides the flexibility of evolving the application
architecture and design as we find more and more pieces of the jigsaw. This helps
us in practicing the true agility in software engineering right from design and
architecture, not just code development cycles.
Developing smaller blocks eases the pressure of coding and
maintaining application modules. Smaller code footprints reduces
dev/test/release cycles. Helps in quickly identify and fix bugs. Quickly
address business process changes as we can quickly build and deploy a new
service without having to fiddle with existing code.
Also, micro-services are completely independent of each of other
interfacing through messages. This improves application cohesion and helps in
scalability. This not only means each can have their dev and ops cycles but
also they can have their own technical stack providing completely technical
freedom. No challenge of deciding the completely technical stack upfront,
application design dictated by technology, tech stack lock downs, challenges in
getting right and enough technical resources to dev and maintain etc.,
Moreover, micro services also help in controlling the technical debt.
Comments
Post a Comment