Is the End of Tiered-Based Computing in Sight?
This morning I came across a whitepaper from GigaSpaces entitled: Space-Based Architecture and The End of Tier-based Computing
Perhaps the most widely adopted style of software architecture is the N-Tier architecture... the separation of concerns based on stacked tiers of functionality. The "Three-Tier" architecture is perhaps the best known N-Tier approach, with functionality separated into Presentation Logic, Business Logic, and Data Access Logic.
The premise put forward by GigaSpaces is that N-Tier solutions are hitting a wall in terms of scalablity, or more specifically that the increasingly complicated schemes necessary to scale an N-Tier solution are hitting a roadblock.
The basic approach to scaling an N-Tier solution is to deploy multiple instances of any Tier that is having trouble meeting the necessary performance goals. For example, if the EJBs in your Business tier can't keep up with the requests from your Presentation tier, then deploy copies of the EJBs on additional servers.
This approach to scaling an N-Tier application works pretty well unless you need to deploy many copies of your Business tier... the middleware necessary to deploy the EJBs and to load balance requests becomes increasingly complicated, not to mention the overhead incurred when sending messages to remote tiers.
GigaSpace suggests a different approach to scaling, which they have christened Space-Based Architecture:
"Space-Based Architecture (SBA) represents a new model that combines distributed caching ("Data Grid"), content-based messaging ("Messaging Grid") and parallel processing ("Processing Grid") for transforming existing tier-based applications into linear, dynamically scalable services. These new middleware components are implemented on top of a distributed shared memory space that provides common clustering, high availability, location transparency and consistency services across all tiers."
The SBA approach is supposed to promise more straight-forward scalability, particularly given the rise of Service-Oriented Architecture and Grid Computing.
Radically simplifying SBA (you really ought to read the whitepaper), the gist seems to be that tiers are not deployed separately. The tiers required to process the application logic are grouped into a single logical processing unit, and scaling is achieved by running multiple instances of those units on multiple machines. To contrast this with the typical approach to scaling an N-Tier application, instead of creating multiple instances of the tiers, the approach is to create multiple instances of the application:
"The power of spaces comes from not having to separate various parts of an application into discrete physical runtimes â€” and then wiring those together in complex, hard-to-scale, and performance-consuming tangles of middleware. A space doesnâ€™t care if an application has been â€œtiered.â€ Whether it has or not, the same program code will instantiate multiple times on the same machine or on multiple machines automatically â€” and even dynamically - in response to runtime parameters like CPU utilization." - Nati Shalom - CTO, GigaSpaces Technologies
At a very basic gut level... this approach seems to have the merit of simplicity: If one instance of the application can't keep up, create another instance of the application (on another machine). Beyond this intitial "gut feel" evaluation, I'm not so sure if complexity is really removed... but it is defintitely shuffled from the perspective of the architect.
So what do you think? Is Space Based Architecture and the emergence of Grids and Service-Oriented Architecture going to change the way most software architects approach their designs... or is this just a niche that won't make much of an impact?
(cross-posted at Thoughtful Programmer)