Karl Reitschuster's Tech Space

Do you remember?

About 10 years ago OODBMS (Poet, Gemstone, Versant, ...) seemed to be starting to replace RDBMS; The idea for using OODBMS was simple - if the programming model is OOP why not persist Objects with an OODBMS directly instead of populating it's properties and class hierarchy into a couple of tables? It was the reason Oracle 8 came with object relational features; But they (OODBMS) failed for following reason:

• Availability
  RDBMS already came with availability concepts like clustering, shadow databases, replication
  OODBMS did not
  .
• Scalability
  horizontal (Cluster) and vertical (massive number CPU/Memory) scaling - RDBMS were mature in doing this, Parallel Query, ...
  OODBMS did not
  .
• Resource consumption
  changing property of an object was not fine grained - the complete object was modified in OODBMS and/or had to be read by the application
  .
• Missing call interface standard
  Every OODBMS had it's own call-API not compatible to any standard
  .
• Missing query language standard
  RDMBS support a common query language
  OODBMS did not or did not support it at all
  .
• Backup and recovery
  RDBMS ensured to get every bit of the last committed data back on disk failure.
  OODBMS did not

ORM the intermediate answer

Then the time of ORM (Object Relational Mapping) arise; Transforming classes into a relational model to store objects into tables. The ORM hided the RDBMS persistence engine from the rest of the OOP implemented application. It's work was to do the mapping and also a lot of work for the database was generated : processing a lot of SQL statements from a source which is not optimized for a relational data model but for an object model.

How to scale 3-tier Web Applications

A Web application with a lot of page hits needs some solid architecture to achieve the load; Usually if the load increases additional web servers were added. This caused additional load to the database. Scaling databases is not so easy if you start to scale horizontally. The application addressed this issue caching some data with some programmed intelligence but every Application server on it's own.

Increasing load for a 3-Tier Web Application could mean a lot of investment on database and SAN Storage area. The load of all Application servers focuses like a burning glass on the database.  The database is still the single point of Availability/Scalability; this concentrates all efforts on Database/Application Tuning and a powerful Infrastructure were the database run.

Terracotta the answer?

Some weeks ago i detected Terracotta in comparison with Oracle Coherence. Terracotte comes not only as distributed caching solution but also supports transactions, has fine graded access to its' objects and in opposite to oracle coherence it stores the objects in an own storage;

• Objects are stored binary - no CPU and memory expensive marshalling is needed
• Object attributes could be updated without update of the complete object
• it's transparent to the java code - hooks in the binary class file
• every Terracotta server stores the objects to disk
• nodes are easy to add and to remove - it scales depended on data package size near linear to number nodes
• Data is distributed dynamically in the grid - that keeps place for runtime optimization

ok it's based currently only on the JVM; But looking at that features we take not only a look behind a new middleware component. It seems that OODBMS is coming back under the hood as middleware with high availability and scalability reducing load of the RDBMS or eliminating it at all.

It depends on what kind of data  you are processing and if there is a need for reporting/auditing stuff to put Objects via ORM into the RDBMS.

Conclusion

With Terracotta the JVM learned to interact/share it's object with another JVM local or via network. It's a component to connect JAVA VM's with a common virtual distributed heap; You could also imagine Terracotta as middleware to attach memory via network - Network Attached Memory (NAM) is the new keyword for this; This brings a new dimension in scaling up JAVA written applications. The future will be very interesting! Yes it's the return of OODBMS!

The Real Grids are coming - but not as database Grid;

Karl Reitschuster