How can Terracotta provide scalability with good performance, where traditional solutions usually fail, and reduce overall costs at the same time? Because it approaches solving the hard problems of clustering Java applications in a really different way. With Terracotta, you get high availability, scalability, and performance - plus some other distinct advantages:
- Focus on building features, not complex clustering logic
- Faster time to market - from less code to write
- Lower ongoing maintenance costs - from less complex code
- No new API to learn - since Terracotta does not have an API
- Eliminate database bottlenecks, and reduce spending on databases
Read on to see how Terracotta is different, and how it can add much more value than competing solutions.
TERRACOTTA CLUSTERS THE JVM
Terracotta is different because it selectively clusters the JVM itself, and as a result whatever is in the JVM can be clustered, with users choosing what to share and what not to share. This is a fundamentally different approach that radically simplifies making mission-critical Java applications highly available and highly scalable.
This means you can scale an application you wrote, not an application a vendor made you write.
TERRACOTTA IS SIMPLER TO USE—A LOT SIMPLER!
Why is it so simple? First and foremost, it's simpler since you don't have to write any code to get the clustered behavior you want. Just tell Terracotta what to do in a configuration file, or by using a Terracotta plug-in for your development tool, and it will place the proper clustering logic right into the JVMs in your cluster.
You don't need to change the code for your application. Scaleout is simple too. If you need to add another server, just add it to the cluster and send work its way and Terracotta will automatically kick into action making that new machine a member of the cluster's shared memory pool.
IT HAS REALLY FAST DATA REPLICATION
Terracotta is also blazingly fast. Since Terracotta hooks into the JVM directly and can observe detailed changes to memory, Terracotta can propagate what we call "fine-grained" changes , and these changes only need to go to other servers that are referencing the object that was changed. Terracotta does not depend on Java serialization, which generally forces propagation of course-grained object changes.
In contrast, with Terracotta only a few bytes of a certain object change, only those bytes need to traverse the network to ensure other servers referencing that object get the update. Also, just those servers who need the update get it. Terracotta does not make indiscriminate copies of data, but rather sends very fine-grained, targeted updates across the network.
Because of these fine-grained and targeted updates, Terracotta can generally perform at 10 to 100 X the performance of competitive solutions in similar use cases with similar workloads.
DEVELOPER BENEFITS
Plus, developers get a lot of benefits they'll love, like object identity that is preserved throughout the cluster, the freedom to focus on building features rather than infrastructure code, and the power to share data and coordinate actions between an arbitrary number of servers.
LEARN MORE ON OUR COMMUNITY SITE
To learn more about how Terracotta alone can provide scalability that's so simple to deploy, check out the Terracotta Scalability Story on our community website, where you can also find product documentation, training, tutorials, and our support forums.
