Oracle Coherence Reviews

I utilize Coherence for data solutions in the financial industry. Its primary use case includes plain lookup, indexing, filtering, and aggregation.

Coherence is beneficial due to its multi-indexing to the same object and filtering based on data attributes within the object, followed by aggregation. These features facilitate querying data with multiple keys rather than just a single key. Its real-time data processing capabilities provide insights for business decisions with up-to-date information.

Oracle Coherence enables our customers to pay their bills and view their usage and all other kinds of information. We use Oracle’s Customer Care & Billing (CC&B) for managing all billing data. Our business customers use it to manage hundreds of accounts.

Mobile devices need to load faster. Coherence lets us retrieve data from the CC&B and the database, build a full user profile, and store this information in the session in Coherence. With this, you do not need the back-end system anymore. After the first login, the site loads faster because it does not need to go to the back end.

We have about 10 servers so that all 10 servers are used for load balancing. If I pay the bill, this information gets passed from one server to the next with Oracle synchronizing the data between servers. I can perform different actions on the same account. That information is handled by different servers, but Oracle synchronizes the data.

The product quality is good. It is stable and easy to use; and increasingly flexible when you scale up.

Oracle Coherence improved site performance and the customer experience. Customers don’t want to see that the site is too slow or that there are breaks in transactions. They want faster access, especially for mobile devices. For people with network bandwidth and a data plan, it has to be faster.

We have our own data center with a lot of servers running on the Linux platform.

This platform has issues with stability and performance.

Oracle Coherence has very strong capabilities related to data affinity and in-place data processing. Generally, an in-memory data grid is key/value storage with all its limitations, exploiting data affinity, and in-place data processing is a key for building complex solutions (e.g., point-in-time aggregation) without compromising performance.

Performance (in a complex, real-live solution) is another strong advantage of product.

There were two key challenges which were addressed with a Coherence-based solution. One challenge is input data caching for the risk computation grid – pro-active caching based on Coherence has improved risk calculation time (by reducing data wait time) and allowed the risk grid to scale with yearly growing volumes. Another challenge is intraday risk – point-in-time aggregation based on Coherence reduced delay between data changes and risk updates.

While you can have a successful career with Coherence just being a get/set man, its true power is realized when you leverage the full scale of the cluster as a whole and exploit its distributed processing capabilities.

For the use cases I’ve implemented, the features I used most frequently and have gone head-to-head with incumbents are as follows:

• InvocationService - I have to admit that I took this for granted up until I went against IBM’s eXtreme Scale. Most organizations want to preload/warm the cache and the InvocationService allows you to issue commands to each member in a distributed manner. Parallelizing this activity gains economies of scale since the load time and rebalancing can be kept to a minimum. Said another way, a million rows can be loaded in the time it takes to load 100,000 if you have 10 storage enabled members. Each member is issued a command which details what rows it is responsible for loading. Coherence provides a number of the libraries required to handle this including ‘retry’ functionality hooks and abstracts all the threading/concurrency logic which would be a nightmare to sort out; as IBM learned on this project. This is in direct contrast to extremeScale’s capability - which relied on leveraging Java’s Executor classes. Basically, they had to roll their own distributed processing engine while on-site.
• Filter, Aggregators and EntryProcessors - Before MapReduce & Hadoop came on the scene in such force Coherence had equivalent functionality that was much easier to use. Filters provide the ability to use conditional boolean logic against your data Out-Of-the-Box. Many fail to realize how powerful this is. In the bake off extremeScale had nothing close to this and therefore had to code it. The requirement was to port a StoredProcedure’s logic, which took 30+ secs to run, into something the grid can run. The implementation was based on an EntryProcessor that leveraged Filters and Aggregators. While I would love to say it was strategic coding ability, it wasn’t - I merely used OOB tools. The end result was that the EntryProcessor, running a complex workflow, was a magnitude faster than IBM’s get() call.
• POF - Portable Object Format is the binary optimized proprietary Coherence serialization. It provides staggering Object compaction. For example, an Item object that was 750 bytes with Java serialization is 31 bytes with POF. This has a rippling impact across the entire app, the cluster, even your network since it needs to handle the chatty cluster members.

The biggest improvement is in speed - everything is faster from record retrieval to workflow processing.

We use 75% of the functionality of the product, including Coherence Incubator (not embedded for our version yet). The most interesting features for us are push replication and write through because these give us a lot of flexibility with data.

From the point of view of push replication, we are able to share data between different projects without attaching original data, so, if any client modified this data by error, it wouldn't affect the rest of the projects.

Regarding the feature of write through, we need to persist to DB a lot of data that changes three times per second. However, this is difficult to support by a database. (We have statistics in Coherence of 120 million puts in the cache.) What we do in this case is write to Coherence and then persist to database in batch mode, so the database receives fewer charges than if the streaming is connected directly.

We are storing information from one of our applications. This allows us to answer requests in milliseconds, while the application would take seconds to answer request from clients.

Coherence allows linear on-line scalability across multiple commodity servers. It’s a very important feature for SaaS providers, as it allows adding and removing resources on demand and without taking your production system down. High availability is a key for financial business continuity, and by distributing clusters across multiple Amazon Availability Zones – while still maintaining very good latency - Coherence is able to sustain hardware or even AZ failure without any interruption on the application side, given that cluster architecture is designed correctly.

We implement ticketing analytics using Coherence.

One of the features that is greatly used by us is clustering, as it allows us to scale easier by creating more and more nodes.

Coherence has helped us to drastically reduce the request time of our web applications.