ObjectFabric is a lightweight cross-platform library which helps developers store and exchange data in real-time with the cloud and between applications. It has two independent components:

A powerful communication layer that can establish bi-directional connections between Java, .NET/Mono (iOS), and Web applications. A typical configuration is to deploy the Java version of ObjectFabric to an EC2 instance and accept connections from Web, mobile and desktop apps. Messages can be text-based, e.g. in JSON, simple types like byte arrays, or the objects below.

A set of special objects, in particular collections, which can automatically track, persist and replicate changes, and support transactions. ObjectFabric introduces a new programming model based on object replication, inspired from source-control systems. Clients can retrieve objects from a server, make modifications locally, and commit their changes. As with source-control, conflicts can be detected and commits are atomic.

Applications can communicate with services on the server, e.g. with MySQL like a typical LAMP Web site, a NoSQL store, or a messaging service. ObjectFabric can also be used to route messages in real-time between applications, e.g. for multi-platform collaborative applications, or multi-player games.

Advanced Objects

ObjectFabric aims to provide objects powerful enough to be sufficient to develop most applications. Instead, today, an application data model is typically designed three times, as objects, relational tables, and messages. Developers also need to write code to transform data between those representations.

ObjectFabric replaces the infrastructure in the red box with a more declarative approach, where developers specify intents like “Replicate this with server” or “Store this on SD card”, high-level properties like consistency or replication priorities, and let the system generate the appropriate messages and storage operations. ObjectFabric makes it easy to work with other technologies, e.g. use a relational or graph database to perform a query best done this way, but now you can use them where they make sense in a multi-paradigm design, instead of for the entire application.

Here is an overview of the kind of objects provided by ObjectFabric, referred to as transactional objects, and their features. They are available on all platforms mentioned above, with slightly different APIs to conform to platform conventions.

• Map, List, and Set collections, objects analogous to arrays, and LazyMap, whose values can be loaded from a store or a server on demand. ObjectFabric also let developers define their own transactional objects. ObjectFabric does not constrain developers to a key/value or tree-shaped data model. Arbitrary object-oriented designs are supported, with graphs and inheritance.
• When a transactional object is sent to another process, a remote replica is created and then stays in sync. In a client-server configuration, the server receives updates from clients having replicas, validates conflicts, and broadcast back the new values.
• Similarly, when an object is added to a store, its content is persisted and then kept in sync. Persistence uses a very efficient schema-less binary format, which has interesting options like keeping a change history in addition to the latest state. Several back-ends are supported, currently file, Berkeley DB, and Cassandra.
• Finally, transactions are supported on objects and integrated with replication and storage. Transactions are very valuable when designing certain applications, and can help maintaining data consistency and with performance. They can also be used for concurrent programming (cf. transactional memory).

Many trivial Web and native applications can now be written entirely using objects, and several advanced scenarios are made dramatically simpler:

• Data-entry applications (Store/load from the cloud, offline cache & sync)
• Monitoring applications, data visualizations, stock tickers (Push to clients)
• Collaboration applications, multi-player games (Exchange between sets of users)

In addition to enabling a simple and powerful programming model, ObjectFabric can improve application performance.

• ObjectFabric never sends the same data twice. Like traditional serialization, when an object is replicated between processes, its content is transferred. However, replicated objects maintain a unique identity in each process, so if the same object or any of its references are sent again later in either direction, only a short id is sent, pointing to the existing remote instance.
• ObjectFabric features a very efficient delta encoding of changes. If a field changes on a replicated object, only this field’s value is sent between processes. Collections use similar mechanisms, e.g. adding an entry to a map requires only this entry to be serialized. On the wire, data is transferred in a compact binary format derived from high-performance trading systems.

ObjectFabric is also very secure.

• All networking and serialization code is written in Java, which eliminates runtime attacks like buffer overflows.
• Data is transferred using typed object serializers, so any non-conforming input is rejected.
• All reads, writes, and method invocations can be authorized from a single point before they are executed.
• ObjectFabric can integrate with Apache Shiro, a security library for user authentication and authorization.
• Connections can be encrypted using SSL. ObjectFabric uses each platform’s native implementation.

The documentation covers the API, samples and internals. Get started today, ObjectFabric is open source (Apache 2.0). Our model is currently based on consulting and customization, and we plan to release an enterprise version with automatic clustering at some point in 2012.