Wednesday Jul 20, 2016

Announcing Coherence

Oracle Coherence is here!  That's a lot of numbers.  Or three, depending on how you count.  What it really means is that this release is a patch-set and not a large new release.  The release is packed full of goodies for users of the new Federated Caching and Persistence features released in October 2015 as part of Coherence 12.2.1, and also contains many improvements for users of any prior Coherence release.

Here is a summary of the changes.  For a full description of the changes in, check our release notes.  

Federated Caching Improvements 

Coherence Session API

  • The Coherence Session API provides applications with a new and recommended interface to get a reference to a NamedCache instance. 

Proxy Tier Management Information

  • New Proxy Tier Management Information includes the number of connections across each proxy server and the total messages that were sent and received. Management attributes are included on the ConnectionManagerMBean and are viewable on the Proxy HTTP Report and the HTTP Servers tab in the Coherence-JVisualVM Plug-in. 

Two Member Partition Assignment

Simplified Configuration of Persistence and Federation with Managed Coherence Servers

Zero Downtime Support

IBM WebSphere Liberty Support

  • Coherence*Web supports IBM WebSphere Liberty 8.5 and higher. Support for Coherence*Web with other IBM WebSphere versions has been removed. See Supported Web Containers for a full list of supported containers for Coherence*Web.

Dynamic Active Persistence Quorum Policy

  • The dynamic recovery quorum policy is used with active persistence and automatically configures the persistence recovery quorum based on a predefined algorithm. 

Friday Jun 17, 2016

Updated Best Practices Whitepaper

An updated Best Practices Whitepaper has been posted to the "Lean More" tab of the Oracle Technology Network Coherence page.  This white paper is a major revision of an older whitepaper developed for earlier versions of Coherence.  

The paper includes sections on

  • Design and Development
  • All Aspects of Testing (production, soak, load/stress, software and hardware failure, recovery...)
  • Capacity Planning
  • Setting up a Production Environment 

All new features of Coherence 12.2.1 are discussed, including

  • Persistence
  • Federated Caching
  • Distributed Java 8 Lambdas and Streams  
Happy reading!  Please send me any comments or requests for future updates.



Wednesday Jun 08, 2016

Docker support for Oracle Coherence

I’m very glad to announce the availability of Coherence on Docker.  While it has been possible to run Coherence within Docker for some time, those deployments were limited by lack of multihost networking in Docker. Since Coherence is multihost in almost all real deployments, this was quite limiting.  

Docker support is provided as a Coherence Community Project at  This will take you to a github repository where all Oracle Docker projects live.  There you will find instructions on building Docker images, documentation for setting up a Coherence cluster with Docker, and special topics around enabling Coherence Extend, Federated Caching, Persistence, Elastic Data, and JMX.  

Docker is supported with Coherence 12.2.1+ and Docker 1.9+, and is, of course, limited to platforms supported by those technologies.  

A list of issues is also provided.  

We welcome all feedback.  

Tuesday May 10, 2016

CoherenceRx: Reactive Extensions for Oracle Coherence

We are pleased to announce the release of a new Oracle Coherence Community open source project.  The CoherenceRx project provides a reactive API for the Oracle Coherence in-memory data grid, based on the popular RxJava library.

It is implemented as a thin wrapper around the Oracle Coherence Asynchronous API, which implies that it requires Coherence 12.2.1 or a newer release.

Why CoherenceRx?

Reactive Programming is somewhat of an all-or-nothing proposition, or as Andre Staltz pointed out in his excellent tutorial:

Everything is a Stream

When you are writing a reactive application and need to access a data source that doesn't provide a reactive API, life can get complicated. In order to simplify our users' lives we decided to implement CoherenceRx and release it as an open source add-on for Coherence.

Using CoherenceRx

The easiest way to include CoherenceRx into your own project is to add it as a Maven dependency (along with Coherence itself and RxJava):




and configure versions within Maven properties section:


Once you have the necessary dependencies properly configured, you can use the static RxNamedCache.rx method to create an instance of RxNamedCache:

NamedCache<Long, Product>   cache   = CacheFactory.getTypedCache("trades", withTypes(Long.class, Product.class));
RxNamedCache<Long, Product> rxCache = RxNamedCache.rx(cache);

Of course, you can also use static import for the RxNamedCache.rx method, which would make the code even simpler.

The RxNamedCache interface will be familiar to anyone who has used Coherence NamedCache API before, with one major difference: all the methods return an Observable.

For example, RxNamedCache.get will return an Observable<V> which will eventually emit the value of the cache entry for the given key and complete:

rxCache.get(5L).subscribe(product -> System.out.println("Got: " + product));

Another important difference is that the bulk read operations, such as getAll, keySet, entrySet and values do not return a single container value like their NamedCache counterparts, but an Observable stream of individual values:

rxCache.values().subscribe(product -> System.out.println("Got: " + product));

This is both more efficient, as it doesn't realize full result set on the client, and simpler, as it allows you to process each individual value as it is emitted by the underlying Observable.

For example, if you wanted to process batches of 10 products at a time, you could trivially accomplish that using bufferoperation:

       .subscribe(productList -> System.out.println("Got: " + productList));

Observing Event Streams

Oracle Coherence provides rich event notification functionality, so it only made sense to provide an adapter that allows you to use RxJava to process stream of event notifications.

CoherenceRx introduces ObservableMapListener, which extends RxJava Observable and implements CoherenceMapListener interface. The ObservableMapListener simply propagates each received event to all of its subscribers:

ObservableMapListener<Long, Product> listener = ObservableMapListener.create();


The above is not very interesting, and could be easily achieved using standard SimpleMapListener. But it becomes a lot more interesting when you start applying various RxJava operators to transform, filter and even combine event streams:

ObservableMapListener<Long, Trade> listener = ObservableMapListener.create();
listener.filter(evt -> evt.getId() == MapEvent.ENTRY_INSERTED)
        .buffer(10, TimeUnit.SECONDS)
        .subscribe(trades -> System.out.println("Trades placed in the last 10 seconds: " + trades));


It is important to note that unlike Observables returned by the RxNamedCache methods, which are 'cold', the ObservableMapListener is a 'hot' Observable and will start receiving and processing the events as soon as it is registered with the cache using NamedCache.addMapListener method.

Because of that, it is important that you add Subscribers to it before calling NamedCache.addMapListener, or you could miss some events.


CoherenceRx is the latest example of how Oracle Coherence continues to improve the developer experience when working with In-Memory Data Grid platforms.  In the past several months, we have provided groundbreaking support for Distributed Java 8 Lambdas and Streams, a new Async API based on CompletableFutures, and, now, support for Reactive Programming.  We welcome feedback on the CoherenceRx project in the comments section below, or, as you use it, you can file issues on the GitHub project page.

Monday Nov 23, 2015

Coherence SIGs in Europe in December

Coherence and WebLogic Server team members will be in Europe the week of December 7 talking about the new Coherence release  as well as new WebLogic Server capabilities that include integration with Coherence such as Multitenancy and Continuous Availability.   For both Coherence and WebLogic, these are landmark releases delivering unique capabilities for both developers (distributed Java 8!) and ops (Multitenancy, Persistence, Federated Caching, Continuous Availability).  We look forward to sharing these new features and getting feedback from our community.


Our week starts in Munich with a Cloud Application Foundation SIG on Tuesday December 8. Full information and registration is available here.  Here is the planned agenda:

  • 9:30 Coffee and Registration
  • 9:45 Introduction to WebLogic Server and Coherence 12cR2 Multitenancy and Continuous Availability
  • 10:30 Fueling Applications with Coherence 12cR2
  • 11:15 WebLogic Server Customer/Partner Presentation
  • 12:00 Lunch (and more coffee!)
  • 12:45 Innovating with Java: Benefiting from Distributed Lambdas and Streams in Coherence
  • 13:45 Q&A


On Thursday December 10 we will be in Madrid.  Email Marta.Salso to register or for details of this event.  The following is a preliminary agenda:

  • 9:00  Welcome and coffee
  • 9:30 Coherence 12.2.1 
  • 10:30 Coherence customer use case 
  • 11:00 Break & networking
  • 11:30 Java 8 with Coherence Deep Dive (Distributed Lambdas and Streams)
  • 12:30 Native JSON/JavaScript with Coherence & JSON/JavaScript


 The London Coherence SIG will be held at our London City Office on Friday December 11.  Full information and registration information is available here.  Here is the planned agenda:

  • 10:00 Registration and Coffee
  • 10:30 Introduction
  • 10:45 Coherence 12.2.1 Update
  • 12:00 Distributed Lambdas and Streams with Coherence Deep Dive
  • 1:00 Lunch and Networking
  • 1:45 Oracle WebLogic Server Multitenancy is Here!
  • 2:30 Coherence Cache Persistence
  • 3:15 Coffee and Networking
  • 3:45 Using Coherence with JavaScript and JSON 

Thursday Nov 19, 2015

Coherence Forums and Support

Do you know that you have ways of getting Coherence support beyond the standard Service Request process? We currently have multiple online forums where you can submit questions about Coherence. In an effort to encourage more open communication, the Coherence team is consolidating these forums.

  • The Coherence My Oracle Support Community (MOSC) has been available to customers with a paid Oracle support contract, and is lightly trafficked. This site will be retired.
  • The Oracle Technology Network (OTN) support forums on allow anyone to post and answer questions about Coherence. This is a more heavily used community forum, and we are encouraging increased usage of this resource.

We hope that this consolidation will provide a more active and open discussion around use cases, design questions, and issues.

The Coherence MOS Community also provided convenient links to other resources, and we would like to ensure that you know how to access these resources once the site is retired.

As an Oracle customer with a current Support Contract has access to MyOracleSupport , have access to Support Notes, Knowledge Documents, and the ability to log a Service Request. You can access all this through MOS:

1. Log onto MyOracleSupport (

2. To access Knowledge Documents enter the product name and some search terms:

3.  This is the screen you see after clicking on Search:

4.  Click on the title of the Knowledge Document you would like to view

5. For the most timely and official resolution of issues, please log a Service Request with from the Dashboard (Bottom right) or the Service Request tab. This requires more detailed information about the product, version etc. We always encourage you to upload a description of the use case, deployment information, configuration files, and log files. For some Service Requests, we may ask you for stack traces, memory dumps, GC logs or other information. The faster you can provide us with this information, the faster we will be able to resolve any issue you may be having.

6.  The News and Getting started sections on the left are very useful for general information about Oracle support.

7.  Access to Coherence Information and Documentation.

8.  As mentioned above, you can access the Coherence OTN Community to ask questions to a wide audience including partners and customers.

9.  We highly recommend that you look at the following knowledge documents:

  • Oracle Support Accreditation - Series Index (Doc ID 1583898.1)
  • Oracle Support Accreditation Series for Level 1 My Oracle Support (Doc ID 1579751.1)
  • Oracle Support Accreditation Series - Oracle Fusion Middleware (Doc ID 1584011.1)

Tuesday Oct 27, 2015

Oracle Coherence 12cR2 Offers Major New Innovations

We are very happy to announce major new innovations with the release of Oracle Coherence 12.2.1 This release is one of the largest we have done and delivers several major features aimed at both developers and operations that improve developer productivity, support infrastructure consolidation, provide better security, and simplify multi-datacenter solutions. We are also announcing a new licensing option for low-cost deployment of small-to-medium sized deployments.

New Features

Coherence 12.2.1 is packed with major new features and capabilities:

  • The new Persistence feature enables Coherence to be a system-of-record and improves time-to-recovery from planned or unplanned, partial or total, cluster outage. Persistence can be configured to work in an on-line mode persisting changes as they are made to the cluster, or to take a snapshot of a data grid. Local disk configuration maximizes scalability, while network-attached storage maximizes availability.   Both data and metadata (indexes, listeners, expiry, locks, etc.) are stored, and recovery is completely automatic.
  • Federated Caching provides support for Active-Active, Active-Passive, Hub and Spoke, and custom multi-datacenter topologies. Implemented at the lowest level of Coherence, Federated Caching takes advantage of Message Bus, Elastic Data, and our new Persistence feature to improve scalability, durability, latency, and configurability of data replication over prior solutions.  
  • Coherence Multitenancy allows WebLogic Server Multitenant applications to share a cluster across a set of tenants and applications, consolidating infrastructure requirements. Multitenancy provides tenant-specific caches as well as shared caches for hosting reference data.  It is fully integrated with Oracle Traffic Director, WebLogic Server, and the Oracle Database to provide an end-to-end multitenant solution.
  • One of our most exciting new features is the integration we have done with Java 8 to provide Distributed Lambdas and Streams. We now provide the ability to execute Lambdas and Streams remotely, using standard Java 8, distributed across cluster members, without the need to deploy code on cluster servers. This provides the ability to do distributed, parallelized stream-based functional programming.  By reducing the need to deploy classes to servers, we have also greatly simplified application upgrade.
  • New Security Features include the ability to do fine-grained Authorization and Auditing of all cache access and updates.   We have also improved our SSL support.
  • For developers, we have also added support for Asynchronous Cache operations via Java 8 CompletableFutures for quicker, parallel execution of multiple tasks as well as a Streaming Async API to improve performance and reduce memory pressure on bulk reads. We also offer improved Generics Support.
  • Customers will notice increased performance from near cache optimizations and automatic, dynamic thread pool tuning. 
  • We have improved cluster and port management, and switched data communications to run over TCP via the TCP Message Bus. We also provide Dynamic Coherence Management Node for Management HA.
  • We also have a number of other goodies, including support for Sliding Expiry, a new cache truncate operation, REST Server-Sent Events, and JSON Passthrough that improve the developer experience and offer new functionality.

New Packaging and Licensing Options

We also offer new (and sometimes free!) options for deploying Coherence in production.

  • Coherence Standard Edition One replaces Standard Edition.   SE One is a low-priced ($800 / socket) dual-server Active/Standby solution that provides all Coherence APIs from Java, REST, JCache, and Memcached clients. It is perfect for smaller deployments where you data fits into a single node, e.g. anywhere up to around 20GB or larger depending on your tolerance for larger GC pauses and need for scale-out. SE One also includes the new Persistence features.
    • The good news around SE One does not end there.  SE One is included in Java SE Advanced (with the limitation that it is a single-server deployment with no standby).
    • Since WebLogic Server Enterprise Edition includes Java SE Advanced, WebLogic customers can now deploy Coherence for free in configurations not needing scale-out or advanced features of Enterprise and Grid Edition.
    • Customers needing the scale-out or other features of Coherence Enterprise Edition or Grid Edition can upgrade without code change since SE One provides the full Coherence API.
  • Real-Time Extend Data Clients are now included for free in every Coherence edition to provide deployment flexibility.  No longer do you need to decide whether you will use near cache or whether you will use an Extend proxy before you choose the appropriate Coherence edition.
  • Persistence is part of every Coherence edition. 
  • WebLogic Server Multitenant and WebLogic Server Continuous Availability  both provide the right to upgrade from Enterprise Edition to Grid Edition. If you own Coherence Enterprise Edition or WebLogic Suite and by WLS MT or CA, you will be able to deploy Coherence GE to take advantage of multitenant and continuous availability features of Coherence in your WLS applications.
  • Finally, we have improved our Free Developer’s License on OTN to allow developers to use Coherence for free in development even after Coherence has been deployed in production. 

I hope this has whet your appetite for Coherence 12.2.1. As you can tell, I am quite excited about it. Please check Coherence 12.2.1 Documentation for more information on the features above and watch as deep-dive videos from our engineering team are added to the YouTube OracleCoherence Channel over the next few days. 

Wednesday Oct 14, 2015

Oracle Coherence recognized as a leader in new Forrester Wave report

Oracle Coherence has been cited as leader and top ranked across several categories in a new Forrester Research report.  The Forrester Wave™: In Memory Data Grids, Q3 2015.  The report, which is subtitled “There Is No Better Way To Achieve Blazing Fast Performance At Scale” analyzes features, market presence, and roadmap of eleven vendors in the In-Memory Data Grid space.

[Read More]

Tuesday Mar 17, 2015

Coherence Patches and Releases

If you encounter a problem with Coherence and want to see if its fixed in the latest patch, you can find all the information you need on the Coherence Community home page. It provides links to all the latest releases for both Java, .NET and C++. It's also available from this RSS feed, if you want to be notifications as new releases become available.[Read More]

Wednesday Mar 04, 2015

Coherence is in the Cloud as Part of Java Cloud Service

This entry is reposted from the new cloud-focused blog at Oracle, "The Cloud Front."


Today we are excited to announce a major product innovation - Oracle Coherence is now available as a feature of the Java Cloud Service (JCS). Effective immediately, users of JCS can use our cloud tooling to optionally set up Coherence within JCS.

Flexibility is a key part of the solution. You can either select an initial capacity for the Coherence data tier:

Or use the "Advanced" option to have full control over the number of virtual machines you want for Coherence, the number of managed Coherence servers per virtual machine, and the heap size of each managed server: 

The WebLogic Management Framework is used under the covers allowing you, the user to develop, deploy, manage and monitor your applications via Managed Coherence Servers.

Because the same cloud tooling creates both WebLogic and Coherence, the experience of using the two together in our cloud is a fully integrated and seamless service. As is standard with JCS, you can patch Coherence as you please in an automated rolling fashion. Backups and restores are fully coordinated with the rest of the stack.

Common reasons for using Coherence with JCS:

  • Offload and protect shared cloud services and databases
  • Deliver real-time data to cloud applications
  • Provide transparency and high availability in the cloud's data grid tier

When running a WebLogic 12.1.3+ environment in the Java Cloud Service you have access to all the Coherence cloud tooling. For Java Cloud Service Enterprise Edition 11g with Coherence, you can manually create your own Coherence cluster.

Over the coming year, we plan to release a number of Coherence-related data grid and caching services. Stay tuned for more details. 

For more information:

Tuesday Jan 27, 2015

Spinning-up a Coherence Cluster with Weblogic Scripting (WLST)

The WebLogic scripting and management features available with Coherence 12c Managed Servers make it easy to create Coherence clusters and manage applications. Using the Weblogic Scripting Tool (WLST),  the whole lifecycle of Managed Coherence Servers can be controlled, from creating and starting a Coherence cluster to deploying Coherence applications.

WLST scripts are written in Jython and can manipulate Weblogic JMX MBean's to manage Weblogic and Coherence. The flexibility and power they provide make it easy to create, configure and startup up a complete Coherence environment - in just a few minutes.  This post will outline how to do just this, using some sample WLST scripts.

Read more here.

Tuesday Dec 02, 2014

Coherence Special Interest Groups [SIGs] Coming to Asia-Pacific!

The Coherence Special Interest Groups [SIGs] are coming to APAC!
Quick jump to Shenzen Dec 8 Beijing Dec 10 Seoul Dec 12 Melbourne Dec 15

We've invested a lot of energy over the years to be sure that you have local or semi-local access to Coherence product management and technical staff. Coming up in this round of APAC SIGs, we have myriad topics that you'll find valuable, including showcasing some customer use patterns, advances in database connectivity, real-time data processing and much more.

You'll also hear a lot about our next major release (12.2.1) and get a sneak peek at some of the new technologies we're including for developers, including utilizing Java 8 (yes, Java 8 - you heard right), and support for maximum-availability architecture [MAA] across multiple data centers.

If you're in China, Korea or Australia, these are can't-miss events! We look forward to seeing you there!

Shenzen, China, December 8
10 a.m. - 4 pm
Agenda topics include Coherence road maps, Best Practices, Real-Time Persistence and Snapshotting, and more.
Full agenda

Beijing, China, December 10
10 a.m. - 4:00 pm
Agenda topics include Coherence road maps, Best Practices, Real-Time Persistence and Snapshotting, and more.
Full agenda

Seoul, Korea, December 12
9 a.m. - 4:00 pm
Agenda topics include Coherence road maps, customer use cases, Database Synchronization, Real-Time Persistence and Snapshotting, and more.
Full agenda

Melbourne, Australia, December 15
10 a.m. - 4:45 pm
Agenda topics include Coherence road maps, Coherence + Java 8, Real-Time Cache Persistence and more.
Full agenda

Thursday Oct 30, 2014

Best Questions: 'Top Uses Cases for In-Memory Data Grids' Webcast

We held a webcast last week (now available free on-demand) on the most common use cases for in-memory data grids, and it was one of the year's most-attended online events. You all kept us busy answering your questions and introducing you to concepts that can help you solve some of your core IT challenges.

We thought it'd be useful to record some of the questions and answers we received just in case you missed them (some questions lightly edited for clarity).

How big is the Coherence footprint ? Does it support Virtual and physical hardware? The software library itself is pretty small, most of the footprint is for storing data. It does support both physical and virtual.
Backend: which languages does it support? example: java , pojo, .net... Java, .NET, C , REST, memcached clients, JCache Clients (JSR-107)
Will cache updating work with version 11gR2? I think I understand your question. You want to know how changes to the database are reflected in the cache. In Coherence 12c, we introduced GoldenGate HotCache, which listens to database change logs and pushes changes into Coherence. This will work with version 11gR2.
Once data is cached on Coherence, what is the criteria to offload the data, will it be taken care of by Coherence, or we need to provide any specific logic/criteria? Offload works by accessing data in a key-based manner. If your application is SQL based and you don't want to change it, Coherence may not be a good fit you, unless you are using some persistence technology like JPA.
What is a Coherence application? This was mentioned in the initial part of the presentation. By Coherence application, we mean an application that uses Coherence. Probably a bad term - some large apps are built on Coherence as if Coherence itself were the app server!
From what I understood, Coherence works with multiple application servers like Oracle WebLogic. Is there any advantage to using Coherence with Oracle WebLogic as compared to JBoss/Tomcat or any other application servers? Yes, we have built-in integration for areas like lifecycle management and monitoring, application deployment, security, simpler session management, and more coming in future releases.
If Cohernece is down due to some reason, will the application will be able to access the original data? If you use Coherence as a "look aside" cache, yes. But most customers do not do this and rely on Coherence being available, together with a reasonable DR and "Maximum Availability Architecture" strategy.
How much data can be cached by Coherence without effecting its performance? Coherence is designed to be horizontally scalable. Customers run 100s of cluster members in some cases, and even smaller clusters can cache TBs of data with no performance impact.
Do we have any reporting machanisim on the caching to get details about highly accessed data & how often? OOTB, Not on a per object basics, but at a certain higher level. We are adding auditing functionality to Coherence soon that may enable you to track that. Today, though, we have hooks where you can insert your own logic to do this.

You can see the webcast in its entirety on-demand, or if you have further questions please feel free to comment here.

What's the Difference Between In-Memory Database and In-Memory Data Grids?

We've gotten a lot of questions recently about the differences between Oracle's announced in-memory database and in-memory data grid technologies like Coherence. Let's clear that up, with a dusted-off excerpt from our "State of the Union" blog a couple of months ago. Just in case you missed it.

The In-Memory Database option has led to confusion in the In-Memory Data Grid market
Let us try to clarify some of the confusion.
Oracle Coherence is not embedded in the In-Memory Option for the Oracle Database. Although we have seen rumors of this to the contrary, this would make absolutely no sense. Coherence is a distributed key-value store; the in-memory option is a columnar store. The In-Memory option is purpose built and optimized to work as one with the database with its primary access method being SQL. (Of course, Coherence is part of many other Oracle solutions, such as Oracle Service Bus which offers web services results caching via a check box, or the Elastic Charging Engine, which is architected on top of Coherence’s fault-tolerant distributed processing.  As you can see, Coherence has become strategic within Oracle.)

The In-Memory Option focuses on different use cases than Coherence. In-Memory focuses on ad-hoc full-table scans of unindexed data.  In the words of Maria Colgan "The main use case for the In-Memory column store is fast analytics, which has very different access patterns to OLTP. Typically analytic queries access a few columns from a table but they examine all of the entries in those columns. You need to scan the whole table or segment, not just a small part of the table to answer these queries.” Storing these columns in-memory, in columnar format, speeds full-table scans orders of magnitude.

By contrast, Coherence focuses on providing scale-out data management and processing to middleware applications thereby reducing load on shared services such as databases, mainframes, and web services.  By caching data in domain object format close the application, Coherence also increases responsiveness and availability of applications. 

Hopefully, this helps you understand some key differences and benefits. 

Monday Oct 27, 2014

Coherence SIGs Coming to Europe in November!

The Coherence Special Interest Groups [SIGs] are coming to a town near you!
Quick jump to Munich Nov 4 Stockholm Nov 5 London Nov 7 Madrid Nov 12

We've invested a lot of energy over the years to be sure that you have local or semi-local access to Coherence product management and technical staff. Coming up in this round of SIGs, we have myriad topics that you'll find valuable, including showcasing the innovative usage of some of our recent 12c release features like HotCache (to keep your cache always-fresh) and Live Events for in-grid data processing.

You'll also hear a lot about our next major release (12.2.1) and get a sneak peek at some of the advances we're making for developers utilizing Java 8 (yes, Java 8 - you heard right), and support for maximum-availability architecture [MAA] across multiple data centers.

Finally, for customers of multiple Oracle products, we're participating in several Cloud Application Foundation SIGs that will incorporate WebLogic and Java at a holistic level. We look forward to seeing you there!

Munich, November 4 [with WebLogic & Java]
9 a.m. - 2:45pm
Agenda topics include Coherence road maps, WebLogic for Java EE Multitenancy, Java 8, Cache and Database Synchronization and more.
Full agenda

Stockholm, November 5 [with WebLogic & Java]
9 a.m. - 2:15pm
Agenda topics include Coherence road maps, WebLogic for Java EE Multitenancy, Java 8, Cache and Database Synchronization and more.
Full agenda

London, November 7
10 a.m. - 4:45pm
Agenda topics include Coherence road maps, Coherence + Java 8, Managing Mission-Critical Large Clusters and more.
Full agenda

Madrid, November 12
9 a.m. - 1:00pm
Agenda topics include Coherence road maps, Coherence + Java 8, Real-Time Cache Persistence and more.
Full agenda


Oracle Coherence, the market leading in-memory datagrid product.
Stay Connected...


« July 2016