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.

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.

From a non-functional side:

• - Horizontal scalability
• - High performance
• - Resilience

From a functional side, we use all aspects of the product in multiple applications. Popular features are querying, aggregations, cluster replication and language interoperability.

Distributed Storage, Service Bus abstraction of service.

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.

• Distributed caching
• Aggregation
• Near caching and expiring policy configuration
• Master nodes and dynamic scaling

Near cache and the ability to implement various strategies, like write-behind and read-through cache.

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.

The EntryProcessor allows you to leverage all of the hardware running Coherence, so you can have a truly grid computing architecture. The feature basically allows you to send logic to the place where the data resides. Because Coherence distributes data across all of the nodes it is running on, you can deal with a massive volume of transactions with maximum scalability.

• Portable object format (POF serialization) that allows objects to be serialized/deserialized between Java and .NET.
• Cache dashboard monitoring that provides reporting at the summary and detail level, such as cache hits and cache object count.

High availability, distributed calculation features, and WebLogic integration are the most valuable features to me.

• Entry processors
• Distributed cache
• Events

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.

We use Coherence to keep aware of critical data. We have millions of customers whose data is in Coherence. Previously, when we stored customer data in the database, it took about seven minutes just to locate one customer profile. About 90% of customer data is static. Since we implemented Coherence, this data is in memory all the time; so the results are found in milliseconds instead of five seconds. Our response time for customers calling us over our portal has reduced drastically. We are now able to provide service to our customers much faster. This is amazing, especially for our customers.

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.

The features that were of most value to us:

• Uptime
• Scalability
• Speed
• The ability to read-through and write-through to a backing datastore (something that other caches usually require a separate solution for)

As well as using HotCache to synchronise a Coherence cache with database tables in real-time, it can also be used to warm the cache by loading an initial dataset. The nice thing about this approach is that cache warming is just an extension to the setup for cache synchronisation.

The most valuable features are ease of use, scalability without too much work, and failover recovery.

Caching: It allows applications to cache objects and application-specific data in an in-memory data grid, which provides substantial gain in performance. In my experience, while working on customers’ solutions where performance is a key requirement, along with robustness and stability needs, I have always found Oracle Coherence as the best solution for integrating with different Oracle products and caching data for application-specific needs.

• Coherence Extend with its concept of a proxy instance, thus allowing flexibility even with the Enterprise Edition
• Read- and write-through capability
• A good community maintaining the Coherence Incubator project: Though this isn’t directly from the vendor, the fact that such wonderful documentation exists makes it easier for the users of the product.
• Ease of clustering and the data fabric operation + querying
• Multi-cast free operation

• Putting and getting data from cache
• Clearing the cache using a batch job
• Querying the cache using Coherence QL
• Trigger functionality used when putting data to cache

• Event driven architecture
• Portable object format
• Live events
• Active - passive replication
• Cache schemes
• Distributed
• Near scheme
• Eviction policies

In order, the most valuable features are:

1. Flexible topology
2. Data affinity
3. Configurability
4. POF (optimized) serialization
5. Support of C++ & Java

• Query response time
• Clustering, data distribution, data affinity

• Memory grid
• Multicast support

In-memory data grid and distributed caching.

The most important features to me are its scalability, high availability, and distributed caching mechanism.

The most valuable features are the entry processors for their atomic update ability; and the ability to route an event to one specific node in the cluster.