Terracotta Builds Java Clusters
The company's CTO, Ari Zilka, said it was important that Terracotta go open source with its products.
LAS VEGAS - Ari Zilka, co-founder and chief technology officer at Terracotta, a Java clustering solution provider, says the company is poised for growth in an era where clusters, grids and cloud computing are becoming commonplace. Zilka, who once held the position of chief architect at Walmart.com, spoke with eWEEK Senior Editor Darryl K. Taft at TheServerSide Java Symposium here.
Can you summarize what Terracotta's mission is and what its software does? I know you have a clustering solution, but what's your claim to fame?
Terracotta's claim to fame is having been the first purveyors of networked attached memory or JVM-level [Java Virtual Machine] clustering in the market. Terracotta helps you scale Java applications linearly across a bunch of machines without making code changes. Further, we help you start simple on one or two nodes and stay simple as you grow. This saves you time and money.
The way we deliver this simple scalability is that we plug in to the JVM instead of to your application's source code. Ours is the only technology on the market that allows applications to trust their local memory view of the world at all times instead of having to work through APIs. This means that we are the lowest latency provider of scaling because your application memory operations happen directly to local memory, always. Simultaneously, we are the highest availability solution because we write all changes to memory to disk in our Terracotta server process. This means an application running on top of Terracotta is completely re-startable from a data center power failure without losing any information.
Users rely on our speed and availability to lessen their dependency on Oracle. If you had a JVM that could spread across hardware machines and whose memory was durable and couldn't be lost even if the JVM was stopped, then there would be a class of application data you just would not bother putting in Oracle anymore. Especially because Oracle or other relational databases tend to get used underneath Hibernate inside Java applications for sharing data across application instances, and for a durable storage end point for business objects.
With Terracotta, just use Oracle for SQL queries and reporting. Otherwise use Terracotta as Network Attached Memory underneath Java machines, making those JVMs look and act like one.
The end result of running an application with Terracotta instead of a database is that developers see a simple object-oriented program without Hibernate or JMS [Java Message Service] while production operations teams find that they have no single point of failure and add-a-brick in order to scale at runtime.
Where does your expertise come from?
Our expertise stems from our work at Walmart.com. There we were the platform team, responsible for the core application server, its scalability and availability characteristics and the ease of development of the Web site running on that application server environment. We learned there that developers find a stateful, in-memory object-oriented programming model easiest to work with, but operators cannot live with the complexity where no JVM can safely be powered down if all data is only in memory. We learned that operations folks benefit from a stateless model where all the data is stored in Oracle and the entire site could be started [and] stopped without losing any data or transactions.
It was at Walmart.com we also learned that Oracle's database is woefully mismatched to the task of supporting arbitrary and linear scale underneath modern n-tier applications. So we at Terracotta have been wrestling with the question for a long time of how to deliver the ideal development model and operating model simultaneously for scaled out Java applications running on top of a database.
You guys recently released version 2.5 of Terracotta [in December]. What are some of the highlights of that release? What have you been working on since the 2.5 release?
Terracotta 2.5 is actually quite old now - 2.6 will be out in less than a month. [Terracotta] 2.5 introduced Maven support for people working with Terracotta during development. It introduced better Hibernate second level cache support, and [offers] a few tuning tools for getting applications running on Terracotta to scream.
While 2.5 was focused on making Terracotta work with more frameworks such as Hibernate, 2.6 has had a singular focus-making it possible for the average user trying to lessen their dependency on Oracle to get Terracotta integrated, tuned and launched into a production environment in seven days or less. To that end we have been doing what I call making the engine bigger and providing more telemetry into what our engine is doing at runtime.
We have now reset the bar for the industry on how easy it is to visualize what a clustered application is doing with its objects at runtime, as well as how easy it is to make an application go faster with minimal changes. [Terracotta] 2.6 is between 30 percent and 300 percent faster than 2.5, depending on the use case. And I personally witnessed, just yesterday, an open-source framework person integrate his technology to Terracotta in under 30 minutes, and then tune it to go over 100 times faster than his initial model, all in less than four hours end-to-end.
The Terracotta model is going to continue to get easier to adopt throughout this year, meaning our focus will remain getting people to production in less than seven days from initial download.