Andrew Powell

Every couple of years I have to stop and shake my head at how damn cyclical (and cynical) this business is.  Sometimes, I can't help but feel like Marty McFly and get the feeling like I've seen all this before.  Everyone is, quite rapidly, getting caught up in the notion of this high experience, mobile, touch-screen, multi-device world and how revolutionary it is.  

We've sung this song before though.  It's nothing new.  

It's kinda like "O Canada" and "My Country, 'Tis of Thee" being the same melody as "God Save The Queen".  We know it's the same tune, just different lyrics.  With that thought in mind, let's take a look back and figure out how we got to this point and where we are going in the future.

When I first started building software (Omnis 7 paid the bills), it was all about client-server computing.  You had to have moderately powered desktops and a beast of a database server to house all the data.  Most of the heavy lifting of the data and logic happened at the client.  The server was, basically, just a database, if not in reality, just a database.  This made updating the applications we built a total pain in the ass because we didn't have a really well built out infrastructure to push updates to our clients.  Hell, even Microsoft sent updates on CD.  I fondly remember waiting to see what was in that month's TechNet update, but I digress.

As server performance increased at a faster rate than desktop performance did, the shift was back towards a centralized-type system that was a lot like the mainframes of yesteryear.  Hell, the system we used was even called MetaFrame to harken back to the mentality that all the processing was centralized.  Metaframe was an absolute disaster, but that's a story for a few beers and another time.  At that point in time, you had all the power you needed on the server to run the app, but you were still talking to the database, which was the centralized server component.  That part didn't go away.  

Not too long after that, along came the rise of web-based UI's.  This moved pretty much solidified the move of all the processing to the massive servers that we had sitting in data centers (or server rooms).  This paradigm gave rise to the concept of a middle-tier that took requests from the client (web server), processed the incoming data, made requests to the database, then sent the results back to the client.  

This was a defining demarcation because at this point, we would never really have all the logic in one place anymore.  The client could render and process some of the data and the server would still do most of the business logic.  This worked well, especially with the introduction of client-side scripting methodologies, like JavaScript.

In the middle of the last decade, we saw the emergence of the Rich Internet Application (RIA), be it AJAX, Flash (and Flex), or whatever your tools of choice were (and maybe still are).  This, again, signaled a new era where we moved a lot of the processing back to the client and relegated a good majority of the middle-tier to things like security and data access.  A lot of business logic moved towards the client applications, again.  

Fast forward a year or two to the present day. Now, we are in the midst of a new multi-device paradigm where we have a legitimate business need to have both consistent experiences and business logic across multiple devices (Android, iPhone OS, Windows, Desktops, etc.).  So what do you do?  Do you spend the extra money to duplicate libraries of business logic across platforms and create a version for Cocoa, Android, .NET, and whatever other platforms on which you wish to deploy your applications?  

In a word, no. 

You do the smart thing and move that common business logic back to the server.  The native user interface serves the relatively simple purpose of providing the face of the application, taking input from the user, prepping it for the middle-tier, passing it to the middle-tier, then processing and rendering the results.  The real work: security, data access, and all important business rules and logic are deferred to the server, again.  

So here we are, again in the circle, moving the most intensive processing back to the middle-tier and leaving our device native code to render the user interfaces.  History would tell us that the next phase of this will probably be much more powerful devices that can handle the processing of complex business rules and crunching larger amounts of data.  Achieving this will require us to find a way to create logic libraries that are cross-device.  That will require a change in the current environment where either everyone, or a good number of vendors start playing nice.  If that does or doesn't happen, history tell us that something will trigger us towards this paradigm in the next two to three years.  Let's hang on and see what happens next.