If you’re lucky enough (or unlucky, depending on how you look at it) to work on an application that sees a lot of traffic, you know the importance of getting that application to be highly available and scalable beyond the humble beginnings of a single WebSphere instance. Keeping your application running in the face of hardware failures, software upgrades, and increasing user traffic is no simple task.

The big challenge is always how to make your application state – session data, caches, indexes, etc. – available across WebSphere instances so that you can add more servers to keep up with user requests as the load increases, and survive restarts of parts of your Web cluster without the end user noticing. This is usually done in one of two ways:

1. Write custom code to serialize that data out to the cluster
2. Write that data out to your database.

While these solutions can be made to work, they are inevitably difficult to work with and hard to scale.

Writing custom serialization code may seem easy to start with, but maintaining it can quickly turn into a nightmare, especially as your application grows and you have more and more state to manage. Keeping track of what has to be serialized and moved around the Web cluster can be a real pain and can really get in the way of adding new features and improving existing ones.

Dumping state into the database just pushes your scalability problems down to the database tier. As your traffic grows, you find that more and more of your database resources are being consumed taking care of application data that doesn’t really belong there. Sooner or later, someone’s going to tell you to stop abusing the database.

Wouldn’t it be nice if you didn’t have to think that hard about scaling your app? 

Terracotta, a San Francisco-based open source company can help. Terracotta has been making it easy to share application data across JVMs since 2005 and is now available for WebSphere and WebSphere CE applications.

Terracotta’s solution is scalable, inexpensive, and non-disruptive. It allows you to store and share temporary application data like user sessions and data caches in a giant virtual heap that we call Network Attached Memory (NAM). This allows many WebSphere instances to share data as if they were all in one big JVM. Objects that are shared using Terracotta are available everywhere when your application needs them without using serialization, abusing your database, or requiring you to write a bunch of custom code to deal with them. Shared objects look, act, and smell just like regular objects. Terracotta works behind the scenes to make them persistent and available to your entire Web cluster.

Terracotta’s NAM approach can restore your database to its intended function as the system of record for your business data. Because it’s transparent to your application code, it provides the necessary infrastructure to make your application highly available and scalable, virtually eliminating the need for custom development. As a business software developer, Terracotta frees you to focus on your business logic instead of developing a non-reusable and hard-to-maintain availability infrastructure.

Terracotta has released version 2.4, which includes support for WebSphere Application Server, WebSphere CE, and the IBM JDK.