Feasting your programming appetite with microservices

ITIL and DevOps CSC Blogs

I have been coding for more than 25 years and have used more than 18 different programming languages (and their associated frameworks), spanning every programming style from simple scripting, to procedural, to objected-oriented, to dynamic and functional — which is more attractive to the software engineering community these days.

Let me confess, every time I switch to a new language or style I always think, “Oh, hope I can also do that.” Trust me, no language is complete; no style is perfect. So, the only way to feast your programming appetite is to try something different which gives more flexibility. I honestly think the microservices style of application is the one that best delivers that needed flexibility…and the fun that most of us are seeking.

But this is not simply said and done. We need a pragmatic answer to the question, “Why is it better and what makes it fun?” In my experience, the biggest challenge in designing and building software systems is the identification of all the bits and pieces of the jigsaw puzzle. As we know, it is never easy to identify the position of any single piece when we start. We get more clarity as we start putting the bits together. But still, we make the mistake of attempting to design a software system up front in a big chunk (typically, we address most of the core and then add more functionality to the core, which oftentimes 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 processes. But what’s the use of an agile process when our engineering approach is monolithic? This is where a microservices approach rocks!

Microservices are small building blocks of an 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 microservice. This simple change in perception around developing applications provides the flexibility needed to evolve the application architecture and design as we identify more and more pieces of the jigsaw puzzle. This helps us practice true agility in software engineering– right from the design and architecture phases, not just in the code development cycles.

Developing smaller blocks eases the pressure of coding and maintaining application modules. Smaller code footprints reduce dev/test/release cycles and help in quickly identifying and fixing bugs. Users can then quickly address business process changes as they rapidly build and deploy a new service–without having to fiddle with existing code.

Also, microservices are completely independent of each other, interfacing through messages. This improves application cohesion and helps in scalability. This not only means each can have its own dev and ops cycles but also each can have its own technical stack, providing complete technical freedom. So you bypass many challenges; there is no deciding the entire technical stack upfront, no application design dictated by technology, no tech stack lock downs, and no challenge in getting the appropriate technical resources for dev and maintain.

Whether it is design, dev or maintain, microservice-based applications rule. They help organizations achieve agility and keep the technical debt in check. All that’s needed is the right approach. We don’t need Rockstar coders, we just need individuals who are willing to see the bigger picture and its flexibility, and are dedicated to continuous improvement. Have you tried microservice-based application build? No? Give it a try, you’ll see. Have some experiences to share? I am all ears…

Sankar Rao Vema — Distinguished Engineer

Sankar Rao Vema is a technology enthusiast, futurist, researcher and author who is an expert in artificial intelligence (AI) and other disruptive technologies. Sankar has a deep understanding of computer algorithms, data science and architecture; can program in 18 different languages; and is an active open source contributor. He leverages his breadth and depth of technology skills in the Advanced Technology Development (ATD) group of the Office of the CTO, where he maps disruptive technologies to advanced AI concepts and showcases his work for clients in ATD centers.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s

%d bloggers like this: