As of late, I've been pondering the following questions, "How did we end up with the Application Server?" or "Is the middle tier just an effort to compensate for really bad persistence technology?"
Looking back over the last 10+ years, my architectures have evolved in step with the available technologies.
In the early 90's I wrote a simple local database application to simulate/evaluate brucelosis inoculation rates in north american livestock based on statistical data from the USDA (for the USDA). This was one of many DBX like applications I cranked out during the time when Novell/IPX and Lantastic were the major network protocols.
Following that, TCP/IP was emerging on the desktop, along with the internet and commodity RDBMS like MS SQL or Sybase. During this period I created a MVC style scripting language (in C++) invocable via CGI, NSAPI, and ISAPI with SQL and raw text (HTML) templating systems. During this time, I was building web based, data driven, applications with only two tiers; the embedded scripting engine and a SQL database (the HTTP server could be seen as a third tier, but the scripting engine actually did the rendering). This held me over till about the late 90's.
The last few years of that decade I worked on a P2P mobile agent framework in Java. The system was perfect for managing manufacturing control systems. But EJB started to emerge and the powers that be wanted an EJB server, not a P2P, transparent object distribution micro-kernel framework. So we twisted a few things around and it became the middle tier. (Rhett got the patent on dynamic proxies.)
For years after that I have been chasing the perfect adaptive object model. One that lives in the middle tier that requires nothing but assembly through an intuitive interface similiar to Objectiva [pdf].
Of course I've found it ironic that I had this, in a small part, when I was doing two tier development using tools like ERwin. What's more ironic is that alot of the projects today are attempting to collapse the last two tiers (rules and persistence) back into one (like Prevayler). What people are striving for is the orthogonal persistence chased after in the late 90's at Sun.
CarrierWave is a perfect example. It is a container looking for the perfect object model. It strives to give you assembly and type-safety, but hasn't offered any business relevant semantics.
So why has this happened? I would expect because RDBMS is not sufficient, so a whole industry has built up trying to fill in the blanks. What would happen if we just fixed the persistence layer, what would we need to be successful? It should be noted that typical RDBMS tools are not rigid implementations of Codd's relational theory, which if implemented properly should be sufficient.
I know this is probably a big 'duh', but looking at the path I have taken, never once have I challenged RDBMS technology with an alternative, I just compensated for it. As have done a few other projects like Hibernate by offering an O/R binding or they have persisted the issue, like MySQL, by releasing yet another relational server.
Of course the relational model has been challenged. But the alternative model I find most compelling is the Associative Model. It seems, on the surface, to share some points with the emerging semantic web. If anyone has a copy of this paper, I would love to read it.
Leave a comment