2014-08-28 - Baratine upcoming webinar!

We will be hosting a Google Hangout Webinar on September 23. For info and to sign up click here for the 10:30 am and click here for the 5:00 pm (PST)!

2014-07-15 - Baratine at LA JUG on August 5

Caucho to present baratine at the Los Angeles JUG on August 5. Meet senior Caucho engineer Nam Nguyen and Chief Evangelist Sean Wiley.

2014-06-17 - Baratine creates buzz at San Diego Java Users Group!

- Simple microservices platform gets a service deployed in 24 minutes

Part One: Slide deck presenting baratine's powerful microservices architecture (PDF)
Part Two: Quick start presentation with code demos (PDF)

Introducing Baratine

Baratine is a new distributed in-memory Java service platform for building high performance web services that combine both data and logic in the same JVM. Say again? In Baratine, the data lives within the service and the service owns its own data. This means:

  1. the data is not owned by the database
  2. the data is not modified by another process
  3. the data is not separate and distinct from the service

=> The data sits right in the service in the same JVM, the same thread, and the same class instance.

How does it all work?

In Baratine, your plain-old-Java-object (POJO) is your service and the fields in the class are your data. Your POJO stays in memory and it holds the authoritative copy of your data. Your service runs at the speed of light because it never has to wait for the database because the data is already there in memory within the service. Baratine does save your data to an internal database in the background for persistence (but that copy is just a backup for recovering from restarts).

Baratine goes above and beyond NoSQL - Baratine is NoDB. Because the POJO is both the service and the data, the database's role is relegated to backup. The POJO has what it needs to complete a request front and center.

Baratine is high-performance

Baratine is single-threaded to enforce a single-owner, single-writer contract. The POJO is the only one able to modify its data because it owns its own fields; there is no need for synchronization and intermediaries (databases or API calls). Without intermediaries and without synchronization, Baratine services are super, super fast.

Baratine's Architecture

The following components make up Baratine:

  • Inbox: ring-buffer queue
  • Journal
  • Distributed SQL-compatible database
  • BFS (Baratine File System): distributed file system
  • Bartender: cloud manager with heartbeats
  • Horizontal scaling with automatic partitioning
  • Web server

Your POJO service

Given your POJO class:

@ResourceService("/counter/{_id}")
public class CounterService
{
  private long _id;
  private long _count;

  public long get()
  {
    return _count;
  }

  @Modify
  public long incrementAndGet()
  {
    return ++_count;
  }

  @Modify
  public long decrementAndGet()
  {
    return --_count;
  }

  @Modify
  public long addAndGet(long value)
  {
    _count += value;

    return _count;
  }
}

Baratine wraps an Inbox, Journal, and distributed SQL-compatible database around your POJO. Baratine then exposes your POJO to blocking and non-blocking RPC calls from Java, WebSocket, and HTTP clients. For example, the following blocking HTTP RPC call:

http://localhost:8085/s/pod/counter/555555?m=incrementAndGet

would return the current counter value in JSON:

[1]

Learn more

DOCUMENTATION
DOWNLOAD NOW
Manufactured by Caucho Technology, Inc.