IT Musings | A ramble alongside code, design, architecture and software development

Services at the cutting edge

Sun, 19 May 2024 08:00:00 +0000

We have been working with a client to develop a cutting edge (no pun intended) Point of Sale (POS) system. The key differentiator is to work offline - especially in geographies where internet connection is unreliable. Our solution was to deploy services at the edge (the store) and the cloud. The store services will need to have the same functionality as the ones in the cloud.

We wanted the edge to deflect to the cloud when internet is UP and running but still store a copy of the entity locally so that even if the internet were to go down...

The Camel Glue for MicroServices

Thu, 15 Sep 2016 01:33:47 +0000

Recently, at E-Bee, I developed a framework for enabling Micro Services using Apache Camel. I have always been a big fan, nay, a fanatic, of modularisation. Combine the modularisation concept with the notion of Micro services and you would stipulate that all modules need to expose Micro services. All the services that are available from one module must be exposable as Micro Services to another dependent module. One module can only consume another module via its exposed services. No back door entry permitted! This means that one module cannot sneak in and take a peek at the other module’s database. Or shared memory....

On the Design of Software Organizations - Balancing Autonomy with Governance

Wed, 22 Jul 2015 00:00:00 +0000

With a spurt in the documented history of any field of endeavor, we will begin to discern some recurring cycles of patterns. What was once touted as the next best thing would have been subsequently denounced only to have it revive later like the proverbial Phoenix with even more vigor. This observation is conveyed by the old chestnut about “history repeating itself”. In the software world, with a decade witnessing the kind of events that used to take a century or more to happen,...

De-coupling releases from deployment

Sat, 11 Jul 2015 00:00:00 +0000

IT industry is all about change. Functionality needs to constantly evolve. You need more content, more products, more promotions and what not. In fact, a static web site is not very interesting in the eyes of its users. It gives the impression that the founders have gone fishing and have left the users to their own devices. Hence software releases are a part and parcel of the lives of all folks involved with IT. In most enterprises, releases are mega affairs. They need planning and a non trivial amount of co-ordination between multiple groups. All teams need to deploy their latest...

What Lewis Carroll can teach us about Web Architecture

Thu, 18 Jun 2015 00:00:00 +0000

“Why it is simply impassible?

Alice: Why, don’t you mean impossible?_

Door: No, I do mean impassible. (chuckles) Nothing’s impossible!”

Lewis Carroll, Alice’s adventures in Wonderland and Through the looking glass

As enterprises evolve, multiple portals emerge to facilitate interactions with the end consumer. So before we can say Enterprise Architecture, we would already have a marketing site, a commerce site, a support portal etc. All of these either become sub domains or individual domains in their own right. The consumer is befuddled by these myriad web sites with their own associated styles, fonts, branding and...

On Technical Debt

Mon, 09 Mar 2015 16:01:32 +0000

Technical debt has been mentioned in multiple blogs. Ward Cunningham apparently coined the term.As a software product starts acquiring more and more features and thence complexity; it tends to degrade in certain ways technically.

If all potential product features are documented in a product backlog, then technical debt is that part of the product backlog that pertains to the maintainability (as opposed to the functionality) of the product.

This definition of technical debt captures our understanding succinctly. Accumulating technical debt may be deliberate or unintentional depending on the actual situation. We will talk about some of the different...

On Micro Services Architecture - Old Wine in a new Bottle?

Wed, 09 Apr 2014 17:57:12 +0000

The Micro Services Architecture has emerged as yet another old wine packaged in a spanking new bottle. Thought Works and Netflix have published this architecture to the multitude with their blogs and frameworks. People have jumped into the bandwagon and have deployed Micro Services for multiple situations. Look at this video for instance. There are about 3500 person days of work which was divided into smaller pieces and executed using Micro services. It is the old unix style, divide and conquer yadda yadda yadda.

But personally I was still confused. I did not understand how you would orchestrate so...

Welcome to Jekyll!

Sat, 13 Jul 2013 00:01:57 +0000

You’ll find this post in your _posts directory - edit this post and re-build (or run with the -w switch) to see your changes! To add new posts, simply add a file in the _posts directory that follows the convention: YYYY-MM-DD-name-of-post.ext.

Jekyll also offers powerful support for code snippets:

def print_hi(name) puts "Hi, #{name}" end print_hi('Tom') #=> prints 'Hi, Tom' to STDOUT.

Check out the Jekyll docs for more info on how to...

Opspeak

Tue, 07 May 2013 00:00:00 +0000

It is one of software’s little ironies that most architects would fervently wish to see their software run forever and yet fail to foresee how the system would be maintained after it goes LIVE.

This is where the operational viewpointshines. This view point could gently steer the straying architects obsessed with functionality back on course and ensure that the system maintainability characteristics are handled as well . Operational viewpoint deals with a set of concerns relating to the maintenance of the system in a production environment by the “Ops” folks. Typical questions that need to be considered in designing...

On Architecture, System Thinking & the Nazca Lines

Thu, 21 Jun 2012 18:43:15 +0000

Legend has it that Bill Gates was the first self proclaimed software architect. Then the fad caught on and the rest is history. Everyone wants to now be part of this selective fraternity. So much so that it is hard to fling a brick in an IT unit without inflicting material harm to at least some person who goes around town proclaiming his membership to this esoteric club. It is hard to distinguish between the true cognoscenti and the dumb wannabes. But who is this person? What distinguishes the average Jo Developer from an architect?

I like to think of...

Stevey Can Rant.. I Cant

Tue, 01 Nov 2011 13:08:39 +0000

Stevey’s Rant has been making the blogging rounds recently. Everyone and their aged and ailing mothers are talking about it including yours truly of course - not my mom though - with this post. I like the rant of course along with the multitude. Who can resist reading contemptuous digs on Jeff Bezos or for that matter on Google or Microsoft? Not me.. Like most wanna be billionaires who has to be content with the measly dole that gets meted out to enterprise architects, I have always looked askance at these “rags to riches” guys with their perceived pomposity...

Ecommerce & Java

Wed, 24 Aug 2011 00:00:00 +0000

I recently spoke at a Java conference in Bangalore where we discussed Java and E-commerce. This is becoming important with the advent of major e-commerce re-platforming efforts in some significantly large organizations.

I am enclosing the deck that I had used in the meeting here.
Ecommerce & Java

Take a look!

Comments

Mridul: Very useful document, Raja. I liked the comparison slides most.

On Digesting XML

Tue, 26 Jul 2011 00:00:00 +0000

One of the earliest uses of XML was for the purpose of storing configuration. It was soon realized that XML constructs are more amenable for specifying nested configurations rather than properties or INI files that were hitherto used for the same purpose. Since I am a confessed frame-workaholic (a term I just coined to denote a person who has a penchant for writing frameworks at the drop of a hat) , I have always been using XML forever to specify configuration for my frameworks.

But how do I go thru this morass of XML configuration and make sense of it?...

EDA and Incremental ETL

Sun, 17 Jul 2011 00:00:00 +0000

Event Driven Architecture (EDA) is a paradigm that I became familiar with when I was coding the earliest GUI components. The user interaction with a GUI application is modeled as a series of events that the application responds to. There is an “infinite loop” of events which can potentially be engendered by user interactions with a graphical application. The user responds to an application by potentially typing on the keyboard, clicking on certain segments of a GUI (such as a button for instance) with his mouse, hovering over certain regions etc. Individual GUI components respond to these events as they...

On Project Ramp ups

Tue, 12 Jul 2011 04:59:18 +0000

As I think back about all the failed projects that I had seen, I recognize one unifying feature about them. They all took too long to ramp up! I am not saying that they did not spend enough time on design or architecture. On the other hand, many of these failed projects spent an inordinate time weighing on alternatives, designing, documenting, estimating the effort and the like. But they failed to recognize one little truth. All the effort expended here is fruitless without code! It is just, as one of my colleagues puts it, “intellectual masturbation” at this point in...

On Estimation & Agility

Mon, 04 Jul 2011 00:00:00 +0000

I was doing an estimation review recently.

At first blush, I am instinctively uncomfortable about anything that requires a high degree of predictability in software development since that is going to be violated if you are ever intending to produce software that could be deemed useful by the ultimate consumers!

It is exactly like doing the interiors of a house which is an activity that I was partaking of recently. I was engaging some interiors contractors to do the work. Their estimation and invoice depended on a simplification. They merely told me that it would cost me a certain amount...

On IoC containers & Stateful components

Wed, 16 Mar 2011 00:00:00 +0000

If we elevate ourselves enough to sit on a figurative perch in the programming world and look down at the applications that are being developed, we realize that Inversion of Control (IoC) containers have most definitely come here to stay. You see more people than ever before proclaiming expertise in programming “Java with Springs” - alluding no doubt to the Spring lightweight container that has now become the de-facto choice to develop most modern J2EE applications. Now it is easier than ever to create components as “Stateless Singletons” and injecting other stateless singletons into them. The whole dependency tree gets...

Calculating percentiles in MYSQL

Sun, 10 Oct 2010 03:53:31 +0000

I was doing some interesting analysis on percentiles. In the process, I had to put some results in MYSQL and use it for calculating them. I am somewhat fanatical about the usage of select statements without recourse to stored procedures for doing anything in the database. So I was hunting for a “pure select” way of accomplishing this. It turns out that MYSQL does support stored procedure variables without mandating the use of the “create procedure” directive. This, to me, represented the best of both worlds. I wanted to avoid the admittedly dubious pain (that springs out of my personal...

IOC, AOP - 101

Fri, 27 Aug 2010 01:11:11 +0000

I had given a keynote in a conference sometime ago, about the Spring framework. It constituted a presentation on the patterns that necessitated the creation of Spring in the first place. I am attaching a slide deck on this. I would add some more material here as we go to elaborate on the content of the deck.

Here is the deck.DIAOP

The Law Of Demeter

Fri, 20 Aug 2010 04:13:25 +0000

Most of us are familiar (or must be familiar) with the law of Demeter (LoD) as documented here. Basically, the LoD stipulates the principle of least knowledge about the internal structure of your dependencies. Or as in the case of this toilet sign, “no looking at what is happening inside”.

Let us say we have a class A that has a dependency on class B which in turn has a dependency on class C. LoD proscribes constructs of the form b.getC() since these would assume that A has intimate knowledge on the inner workings of B - in this...

The n+1 selects problem..

Sun, 20 Jun 2010 00:00:00 +0000

A few years ago, one of my numerous job sojourns took me to an interesting project at a telecom company. I was a developer then - as I would like to think of myself today as well - and had to maintain code that connected to numerous databases and published various services. In one of the C++ classes, the code issued a database query that obtained a set of rows from one database table - let us call it T1. It then looped through the result set and for each one of the returned rows, it invoked...

On Enterprise Architects..

Fri, 18 Jun 2010 18:18:55 +0000

So I had yet another meeting with an enterprise architect today. We were selling a solution to their company which is one of the top few companies in the world in their professed field of expertise. Let us call this guy John to give him an identity despite the fact that, to me, he looked like Yet another faceless EA who threatened to morph into the background. John brought along someone else whom I would christen Little John. Little John is presumably mentored by John and keeps constantly glancing at John to secure his tacit approval for whatever he is...

App Optimization - Asynchronous Pre-fetching Strategies

Tue, 18 May 2010 18:30:16 +0000

I remember perusing through an article on web services some time ago where the author quips about the similarity between web services and teen sexuality. He said that in both cases, they talk more about it rather than do it and even if they do it they do it pretty bad. A similar comparison can be drawn with pre-fetching.

Pre-fetching is one of those things that sounds almost cliched in that everyone talks about it. But I have seldom seen good implementations. How do we know what to pre-fetch? And when would be an appropriate time for that? Who owns...

Application Optimization - Design in Retrospect

Wed, 05 May 2010 00:00:00 +0000

Application Performance and endurance tests are a terrible duo. They let a badly designed application fester unnoticed for a considerable amount of time. The development team languishes in the bliss provided by the lack of attention and gains confidence in its ability to slime the ailing application into production. And lo! in one sudden swipe of the blade, these two hack the application into a million pieces!

Good upfront design is the best tool that will stand you in good stead when confronted by this onslaught. But we all know that in the pursuit of functional requirements, we allow everything...

Perf Analysis - Browser Caches & Response Code 304

Thu, 29 Apr 2010 00:00:00 +0000

With no offense to the favored species, here is a bad joke about blondes:

Question: Why is it a bad idea to give the weekend off to a blonde?
Answer: Because you have to retrain her on Monday.

But browsers, unlike blondes, learn from experience and keep these learnings for sometime. Which means that if a browser has taken the time to download a certain URL, then it tries to keep the resource in its cache for later retrieval if the user has requested for that identical resource during a certain period of time so that it...

Perf Analysis - Web Layer & Browser

Wed, 28 Apr 2010 15:53:48 +0000

This article delves more into the performance analysis exercise that I alluded to in a previous article. We begin our analysis with the web layer which serves as the entry and egress to our core application. Does your web layer buckle under load as the spider’s web here seems to have ?

Tweaking the web layer is often left to the idiosyncrasies of the infrastructure team. When was the last time that as an application architect, you looked at the browser behavior or the httpd server settings?

Or the caching behavior of your JSP pages?...

Performance Analysis of a web application

Sat, 24 Apr 2010 05:10:25 +0000

Application performance testing is just about the last thing that we may have to do before we could certify an application as production ready. Or it may be just about the last thing we do before we decide to discard the app in the dumpster. This may be a loud roar or a death knell depending on what turns up. Or it may be a combination of both. I was perusing a forum the other day where the questioner asked about the appropriate time for application optimization. I have to concede that I was pretty astonished at...

Bug Driven Development

Wed, 21 Apr 2010 00:00:00 +0000

Some time ago, I was exposed to a project which entered UAT with over a thousand bugs. Obviously, the project itself is not the epitome of perfection. But the sheer number begs some fundamental questions about the assertion that the project was even deemed as code complete to enter into UAT. In general, it has been my observation that software projects get reactive when deadlines get squeezed. Everyone is in a perpetual state of hurry to head to the next milestone - be it requirements completeness, UAT readiness or even production readiness. In this furore, thoroughness takes a back seat...

Domain Model and Application Contracts

Thu, 18 Mar 2010 00:00:00 +0000

We had spoken before about the application contracts. As we define components, it is imperative that we spend sometime in designing the interfaces that they expose. Let us go back to the diagram that we used when we designed components.

In the other post, we had decided that the best way to abstract the UI and service components is via the use of a contracts module that contains the interfaces exposed by the services layer. Where does the domain model fit into that picture? That would be the theme of this post.

The domain model represents...

On Program Contracts

Sun, 07 Mar 2010 00:00:00 +0000

Contrary to possible expectation, this post is not about signing contracts between companies. It is the contracts that must exist between the various modules within an application. Any application would have a lot of classes that implement various parts of its functionality.

The interface based design principle stipulates that implementations must be fronted by an interface. This would facilitate a loose coupling between an implementation class and its consumer.

Let us say that the implementation class provides a business functionality which is exposed as a service. It resides in the services module. The consumer is a UI class that stays...