Continuum: Benefits

Continuum supports agile development

Continuum's principal role in any software project is to foster agile development. Most architects realise that agile development is about flexibility - speed is a desirable side-effect brought about by the leaning of the process. What agility takes away is rigorous planning, replacing it with a promise that anything can be changed down the track. And this is true up until the service goes live. From that point on, data has a big say in how the application evolves.

Relational data modelling is to this day by far the most common means of describing an application's storage requirements. The database becomes intrinsically aware of the application's model which makes it possible to refactor the data using tools that work with most database products. While relational models can depict the bulk of persistent data, they often fall short on their ability to model loosely structured data - information that can exist in so many forms that creating and maintaining the corresponding tables becomes unfeasible. Databases persist semi-structured data in dedicated fields and remain agnostic as to their content and meaning. Consequently, databases don't allow refactoring of semi-structured data - leaving it up to the application to carry out this non-trivial task. Because this problem is inherently difficult, it has an impact on product development, as the latter has to cater for legacy data. Refactoring semi-structured data eliminates this overhead, making it possible for the application to evolve without the fear of orphaning existing records. This is rightfully considered the "holy grail" of agile software development.

Continuum fills in what the database leaves off. It makes the storage system "aware" of the data, allowing it to interpret the underlying structure and content, rather than blindly retaining it on behalf of the application. Using Continuum, the database can be "told" to restructure the data in accordance with a set of rules, thereby upgrading the tenured data to comply with the present-day schema. The data can be morphed into any structure, no matter how complex the transformation.

Continuum is non-intrusive

The software development industry is witness to countless examples where new technology fails to replace its inferior predecessors. It can be dismissed on the grounds of being "unproven", or deemed to difficult to integrate into the existing process or application. Enterprise applications comprising of hundreds of thousands of lines of code cannot be easily adapted to a different storage platform. Nor do they need to: Continuum offers a plug-compatible replacement to the Java Serialisation API that is the cornerstone of many semi-structured data persistence solutions. Serialisation is even used as an addendum to relational databases to make them more versatile and cater for all of the application's storage requirements. Because Continuum is 100% compatible with the Java Serialisation API, it integrates seamlessly with little development effort and without the fear of breaking the application. And just because Continuum replaces Java Serialisation, it doesn't mean that you're stuck with a binary format - Continuum supports XML and JSON too.

Enterprise applications utilising serialisation may already contain schema migration rules in form of "read resolve" methods. Although highly limited in their evolutionary capabilities, "read resolve" rules are the only avenue by which traditional serialisation formats can read tenured data. Continuum's compliance with the serialisation API ensures that no part of this investment is forfeited during the transition to Continuum. As an added benefit, Continuum can automatically adopt your existing rules and remove them from your domain classes.

Continuum can natively wire into an application through specialised JDBC driver middleware, supporting all major commercial and open source databases. Changing over to a Continuum JDBC driver is only a matter of changing the database URL in your application server. The JDBC driver will perform all necessary schema transformations when the application requests an object from the database. The stored object will be transparently upgraded and the delivered object will conform to the current schema.

Continuum is fast

For operations that don't involve schema migration, benchmarks of Continuum have shown that it is just as fast as regular Java serialisation and the compactness of the resulting binary data is also on par. However, if multiple versions of data exist, Continuum is actually faster and the output is more compact. This is because unlike traditional serialisation that must never remove a field to retain backward compatibility, Continuum can strip out unused fields when writing data in the new format. As such, applications switching to Continuum can improve their throughput and latency characteristics.

The migration rules are themselves lean - written in Java and compiled to bytecode. Because migration rules are changed less frequently than the rest of the application, they can be pre-compiled and excluded from the application's routine build process. Contrast this to traditional serialisation, where the migration rules are permanently embedded in domain classes. The classes are cluttered with code that can never be removed and are re-compiled on every code change and loaded at runtime. By decoupling schema migration from domain classes, Continuum decreases the build time, start-up time and memory footprint. By stripping out unused fields, Continuum accelerates the application's performance and decreases storage utilisation.