Category Archives: software architecture

Software Architecture

Coherence SIG: Spring Edition: 3rd May, 2011

Updated: The registration is now open here:


3rd May, 2011
Oracle London
One South Place,
London. EC2M 2RB (Google Map)


The theme of this SIG is to discuss and cover in some detail, the latest (to be released very very shortly unless there’s some kind of disaster), version of Coherence.  Essentially the morning will cover Coherence, the afternoon will cover Incubator examples (also being released simultaneously).

For this SIG we’re only running a single track, simply to focus on the latest release.  For the next SIG we’ll be running multiple tracks again.

10:00 Registration

Registration, Badge and Schedule Pick Up.  Tea, Coffee and refreshments served.


10:30  Coherence 3.7 Update: Part 1 (Brian Oliver and friends, Oracle)
In this talk we’ll take a look at some of the latest features in Coherence 3.6+.  More details to come once it’s released.

11:45  Coherence 3.7 Update: Part 2 (Brian Oliver and friends, Oracle)
The follow on session from Part 1 🙂

13:00  Lunch

13:30  Evolution of Gridman (Andrew Wilson)
In this talk, Andrew will walk through the architectural progression from “put-get” man right through to real-time-scalable-events man. It took him 4 years to make this transition and he’s still learning!

14:45  Incubator 10 Goodies: Testing and Tooling (Brian Oliver, Harvey Raja, Oracle)
Finally it’s here and there’s a lot of new goodies.  This talk will focus on Testing and the latest things in Coherence Common, including reflection-based POF serialization

15:45  Break

16:15  The Event Distribution Pattern (Brian Oliver, Oracle)
In this talk we take a look at the newest edition to the Incubator, the Event Distribution Pattern, a simple pattern enabling the distribution of application level events to multiple devices and/or clusters.  Now the basis of latest Push Replication Pattern, the Event Distribution Pattern opens up an entirely new range of new architectural styles for your applications.

17:00 (to be announced)

17:45 Close


Trading Applications Developer Workshops

If you’re in London on March 1st or New York on March 15th and have an interest in trading application development then you might be interested in the following Oracle, Sun and Intel event.

Trading Applications Developer Workshops

The presentations cover a range of technologies, from each layer in the stack, that should be considered when designing or maintaining trading applications.

London Coherence SIG: Winter Edition: 27th of January, 2011

Happy New Year!
I hope you had a fantastic 2010 and 2011 is even better.

For 2010 the Coherence SIGs were a huge success, expanding into even more cities around the world, bringing in a large variety of speakers and expanding the content covered. In London we moved to the full day format which has proven to be really successful.  The great thing is that 2011 is going to be even better, promising more cities, even more content and especially, the release of Coherence 3.7 (at some point).

To kick things off for London in 2011, the next London Coherence SIG, scheduled for the 27th of January 2011, will run all day and with two parallel tracks.  That is, we’re going to double the number of seats available, double the content and double the number of speakers.

Registration for the SIG is now available online at the UKOUG site here:

NOTE: You’ll have to choose which of the tracks you’d like to attend during registration.  But don’t worry you can change on the day.

Look forward to seeing you soon!


27th January, 2011
Oracle London
One South Place,
London. EC2M 2RB (Google Map)


10:00 Registration

Registration, Badge and Schedule Pick Up.  Tea, Coffee and refreshments served.

Knightsbridge Track

10:30  Coherence Update (Brian Oliver, Oracle)
In this talk we’ll take a look at some of the latest features in Coherence 3.6, briefly discussion Coherence 3.7 and what’s new in the latest Coherence Incubator Release, including annotation driven serialization.

11:45  Inside the Coherence Management Framework (Everett Williams,
As the lead engineer and contributor to the Coherence Management Framework, Everett (now working at will present an inside view of the Coherence Management Framework, how it works, is put together, things you may not know about and how to use the JMX Reporter.

13:00  Lunch

13:30  Testing Coherence-based Applications (Andrew Wilson)
Testing distributed applications, especially those that use Coherence, typically requires a little more effort than a  single threaded/single process application.  In this talk Andrew will discuss and demonstrate a number of tips and tricks covering unit, integration and performance testing that will make your life easier when testing Coherence-based applications.

14:45  Coherence Performance Under The Microscope (Tom Lubinski, CTO,
Using the Coherence API is relatively easy, but how your calls onto the API are measured and reported is something different all together.  In this technical talk Tom outlines the underlying schematics of messages, requests and tasks, things that you commonly seen in JMX.  He discussed what are they, why should you care and which ones are important, especially in a production system. Tom Lubinksi then explains how these metrics relate to the workings of the distributed cache service, the invocation service and entry processors.  He will show you how to plot these metrics  to literally “ see” how Coherence is executing your code and using system resources. These insights can then help you tune and troubleshoot your data grid.

Tom founded SL Corporation in 1983 and currently serves as the company’s Founder and CTO. He has been instrumental in developing RTView, a real-time monitoring, analytics and visualization platform, as well as RTView Oracle Coherence Monitor and Viewer for the monitoring and management of Oracle Coherence data grids. Since founding the company, he has been involved in thousands of successful customer deployments of real-time visibility solutions. He has an immensely deep understanding of monitoring and managing distributed systems.  He’s an entertaining and talented speaker with a passion for technology.  Not a talk to be missed.

15:45  Break

16:15  Where does it run? (Andrew Wilson and friends)
In this talk Andrew (and friends) walk through the numerous APIs, extensions and plug-ins available to developers in Coherence, what they are, how they work and importantly where they are executed, knowledge that’s crucial to know if you want to take full advantage of your investment and save yourself some time.

Guaranteed to be an entertaining talk about there experiences in learning the Coherence API, including what they learnt, mistakes they made and their recommendations for each feature.

17:00  Java Platform Update (Sten Garmark, Oracle)
While not specifically focused on Coherence, in this talk we discuss the road ahead for the Java Platform, including the up-and-coming Java 7 and 8 platforms.

If you’re interested in what’s coming in Java and would like an opportunity to interact directly with Oracle Java Product Management, this will be a great talk.

17:45 Close

Waterloo Track

10:30  Beyond Caching and Data Grids:  Lessons in using Coherence as a System of Record  (Ben Stopford)
For most Coherence Architects, denormalising an object model to scale out data access and parallelize queries is a bread and butter activity. However when attempting to use Coherence as a system of record, especially in much the same way as one would use a traditional database, so that things like versioning and joins are easily permitted, normalizing the object model is what you really need.  Unfortunately having a completely normalized relational model will often lead to some serious scalability and or performance challenges.  Likewise having a completely denormalized model will often lead to large amounts of communication to perform things like joins.

In this technical talk Ben outlines the use of Star Schemas and how the adoption of data-ware housing approaches with Coherence provides a mechanism to represent and manage cached data in a normalization manner so that joins (and versioning of data) are possible without sacrificing too much performance and maintaining linear scalability.

11:45  The Live Object Pattern (Brian Oliver, Oracle)
In this talk we’ll introduce the concept of the “Live Object Pattern” and how Live Objects may be used to model configuration, scheduled jobs and points of integration with non-Coherence resources.

The Live Object pattern is fundamental to other pattern implementations, like the Command, Messaging and Push Replication.

13:00  Lunch

13:30  How To Build a Coherence Practice (Craig Blitz)
In this talk Craig discusses what happens after you’ve chosen and started to adopt Coherence.  ie: when the hard work begins.   The talk will help you get the most out of your investment both from a project and enterprise perspective by introducing you to the resources available from Oracle and through the Coherence ecosystem. He’ll discuss best organizational practices we’ve seen and how you can implement them to ensure success with Coherence. Drawing on significant experience with customers’ Coherence deployment, Craig will show what works and what doesn’t in practice.

14:45 Integrating Coherence and OSGi (David Whitmarsh)
In this technical talk David discusses the steps to integrate Coherence with OSGi.  David outlines the challenges, how to’s, traps and benefits of adopting a modular architecture with Coherence.

If you’re interested in adopting Coherence in an OSGi container, or even building a modular application with Spring, this is a great introductory talk.

15:45  Break

16:15  Cool Coherence Features (Harvey Raja, Oracle)
In this technical talk Harvey walks through some of the new features in Coherence 3.6, including Quorums and Default Serializers.  Additionally Harvey presents the new CohClipse plug-in for Eclipse, a tool to help generation serializers for Coherence.

17:00 Developing Custom Push Replication Providers (Brian Oliver, Oracle, with Solace Systems)
In this technical talk we discuss the development and configuration of custom Push Replication Providers, including the new JMS Push Replication Provider, that allows Coherence to use standard JMS providers as a means to manage replication state.

As a demonstration we’ll show how to configure Push Replication to use a Solace Messaging Appliance as replication infrastructure.

17:45 Close

London Coherence SIG: Spring Edition: 10th June 2010 (registration now open)

The registration for the next London Coherence SIG, occurring on the 10th of June, is now open.  However before you rush to register, there are several important things to note.

1. This event unlike previous London Coherence SIGs is being run over an entire day! That’s right.  An entire day! We have so much content and so many requests for talks that we’re expanding the London Coherence SIG.  As a trial we’re organizing the day as follows;

In the morning we’re running several workshop sessions.  These will focus on core concepts and some advanced use-cases. They are designed to be informal with plenty of opportunities to ask questions, provide feedback etc.

In the afternoon we’re running the usual presentation sessions, much like the regular Coherence SIGs that we’ve been running for the past few years.

Given this new format the SIG registration process has changed a little.  Like before you still register for the entire Coherence SIG with the UKOUG, but as part of the last stage of the process you must now nominate which of these sessions you’d like to attend (or both if you like).

The registration page, hosted by the UKOUG is here.

As before, the event is free for all to attend, but please remember if you register but then can’t attend, please let us know as we do incur costs for non-attendance.  ie: catering is not free for us.

2. Given the growth of the Coherence SIGs, us constantly running out of space and having waiting lists, we’re changing to a larger premises.  This event will be held at the Sun Microsystems Office, not the usual Oracle Office.  Here’s the new address.

Sun Microsystems: Customer Briefing Centre
Regis House
45 King William Street

Here’s the Google Map.

3. We have some great talent talking at this SIG.  While I’m sure all of the workshops and presentations will be helpful, I’d especially like to point out that we’ve got Gene Gleyzer (Chief Architect of Coherence) and Patrick Peralta (Senior Engineer and Production Guru) coming over from the Boston-based Coherence Engineering group to present.  These are talks you shouldn’t miss.

Ok… here’s what you’ve been waiting for.  The final agenda.

Workshop Sessions

10:30 Workshop Registration and Welcome

11:00 Workshop: Coherence Cache Configuration and Deployment Patterns (Brian Oliver, Oracle)

In this workshop we discuss the various common Coherence Cache Configurations and how they relate to deployment patterns.  We’ll cover all of the common cache configurations and deployment topologies.  If you’re just starting with Coherence, this talk will be invaluable to help you build your deployment model.

11:45 Workshop: Coherence Monitoring & Management with Geneos (Nick Pike, ITRS)

ITRS Geneos is an enterprise standard for real-time infrastructure and application monitoring in three of the top five investment banks. It is a proactive, real-time systems management tool used to provide a unified view of production systems from an IT and business perspective.

In this workshop Nick outlines how Geneos has been used by a number of customers to monitor and manage both Coherence infrastructure and applications built on Coherence. During the workshop a demonstration will highlight how managing Coherence is simplified from an operations perspective and how the tool may also be used to simplify application development, including automated housekeeping like memory management and rolling restarts.

12:30 Workshop Lunch

Please Note:  The workshop lunch is only provided to delegates that attend the morning sessions.

13:00 Workshop: Understanding Rolling Restarts and Upgrades (David Felcey, Oracle)

Providing 24×7 uptime for a Coherence Data Grid requires planning. This workshop will discuss and demonstrate how database tables, cached data objects and clients can be upgraded in a running data grid with no downtime. It will also address operational issues and outline some of the limitations of performing rolling upgrades.

14:00 SIG Registration and Welcome

14:30  Presentation: More Coherence War Stories (Patrick Peralta, Oracle)

In this talk Patrick outlines some of the more interesting Coherence battle stories and the challenges sometimes faced in real production environments with real customers (who lived happily ever after.)  Patrick then discusses operational best practices to avoid such issues and what to do if (when?) they arise.

15:15  Presentation: Coherence 3.5 Advanced Topics (Dr Gene Gleyzer, Oracle)

In this talk Gene discusses some of the more advanced features of Coherence 3.5, including the Service Guardian, Partitioned Backing Maps.  If you’ve ever wanted to know more about how Coherence works, especially the advanced features, this talk by one of the founders of Tangosol and the Chief Architect of Coherence shouldn’t be missed.

16:00  Break

16:30  Presentation: Developing Scalable Queried with Coherence (Patrick Peralta, Oracle)

In addition to the Map based API, Coherence provides a rich API to allow for parallel querying of objects using arbitrary criteria. This talk will explore various techniques for creating efficient and scalable queries with Coherence. Although the query API is simple from a developer point of view, writing queries that yield scalable performance requires upfront design. We will consider query patterns (and anti-patterns) and explore the tools Coherence provides to develop efficient and linearly scalable queries.

17:15  Presentation: Introduction to Push Replication 3.0 (Brian Oliver, Oracle)

In this talk we’ll outline the next generation of Push Replication.  We’ll cover how to use declarative configuration, instead of programmatic configuration, and how to replace the internals, like replacing Coherence Messaging with JMS.

18:00 Close

Looking forward to catching up with everyone and hearing the feedback for this event.



London Coherence SIG: Spring Edition: 10th June 2010

Save this date:  10th of June 2010 (Thursday)

That’s right.  It’s time for another London Coherence SIG.  While it’s probably a bit late to be called the “Spring Edition”, unless London starts to warm up quickly it probably should be the “Winter Edition” again.

This SIG promises to be larger than ever, in size and content!

1. We’re moving to a new premises (the Sun/Oracle Offices on King William Street) to allow for significantly larger turn out (nearly double the capacity).  Hopefully we can avoid having waiting lists from now on!

2. We’re going to be running tutorials/master classes/workshops in the mornings.  The usual SIG presentations will kick off at around 2pm.

3. We’ve got some great speakers lined up, including Gene Gleyzer and Patrick Peralta from the Coherence Engineering team in the United States.

4. We’ve also got a bunch of new announcements around the Incubator.

More details to come next week… including the full schedule and place the register.

Have a great weekend.

The Oracle Coherence Book!

It’s finally done!  The first book about Oracle Coherence is now available for pre-ordering from the publishers website here. Supporting it’s release, an interview/conversation with Aleks Seovic (the lead author) and Cameron Purdy (VP of Oracle Coherence Engineering) about the book is available here (mp3).  If you pre-order it’s about 10% cheaper!

<snip>Authored by leading Oracle Coherence authorities, this essential book will teach you how to build high-performance applications that scale to hundreds of servers, without single-points of failure using Oracle Coherence. You will learn when and how to use Coherence features such as distributed caching, parallel processing, and real-time events within your application, and understand how Coherence fits into the overall application architecture.</snip>

For those of you who don’t know Aleks, he led the implementation of Oracle Coherence for .NET and was one of the key people involved in the design and implementation of Portable Object Format (POF), a platform-independent object serialization format that allows seamless interoperability of Coherence-based Java, .NET, and C++ applications.

Basically… he knows he’s stuff.

[Update: He’s going to be making an appearance at the London Coherence SIG this week.   He’ll be talking a bit about the book and the tools he wrote (available online) for Coherence]

Ridiculous class and interface names, fear of change and the new operator

One of the important tasks when designing software (or probably anything for that matter) is creating appropriate/correct/reasonable names for things, whether it be for classes, interfaces, methods or variables.  Why?  Simple… When someone reads your code they should ideally require little additional documentation, third party contact or alternative education/context to work out what something means, or determine it’s purpose.  Perhaps it’s not always the case, but it’s a good goal.

While it may seem easy experience shows that creating reasonable names often requires a lot of thought.  In the Coherence team we invest a lot of time in finding names and defining the language of concepts, not only for ourselves, but also for external groups that depend on our code (like customers). Likewise in the Coherence Incubator team, we critically review the names we’re proposing for things, because we know that customers (and competitors) will read our code.  Many a “warm argument” has occurred due to the naming of things, and to me it’s both one of the toughest and most enjoyable things to do.  It’s a critical part of our design process.  There’s nothing like finding a good name to describe something elegantly.  So much so, we often invest time searching dictionaries and thesauruses just to find inspiration.  To me… a name is worth a thousand words.  Unfortunately we don’t always get it right, but we do try, and we try very hard.

When I look at a problem, design or have to reflect on an existing architecture, I start with the names of things.  If I find a name I’m uncomfortable with, or something that requires a lot of explanation, I start to challenge that design is possibly wrong.  ie: It’s overly complex or overly generic and with more thought it could be radically simplified.  Why?  I think this steams from my strong belief that the purpose of writing (commercial) software is to deliver a solution, and with that, there needs to be simplicity (such that we can deliver on time and provide value).   This doesn’t mean a lack of features. It simply means delivering something that is easy to use and is suited for purpose.  It’s about keeping customers happy.  Like Coherence.  Small, remarkably simple yet powerful without a massive API.

SIDE NOTE 1: Sometimes thing’s just can’t be simple… but it’s a good goal to ruthlessly attempt to achieve.

Personally I believe one of the biggest challenges when naming something is the fear of change and the apparent need for developers to “allow for the future”.  Delivering software is a tough enough job as it is, but having to design in solutions involving predictions about the future,with an uncontrollable urge to make things extensible only makes things much harder and more complicated. When I look at a system I intentionally try to limit the amount of “framework building” (accept when asked to develop a framework that is), and instead focus on providing a solution as soon as possible.  I strongly believe that the future is for another version.  ie: Don’t attempt to build 2.0, 3.0, 4.0 etc into 1.0.   Ruthlessly protect and deliver version 1.0, because that may be your last version.

So how does this related to names?  Let me give you a simple example.

Say I need a class to represent a Person.  It has a few attributes, say, First Name, Last Name and Address. You know, it’s nothing to complicated.  That’s all I really need for version 1.0.  While it sounds simple, here’s often what I see happening;

1. Developer decides to model this as a simple Person class.  Great.  Satisfies version 1.0 requirements.

2. Then out of fear for the future, change, the pain change can inflict and the remote posibility that they may need alternative implementations, they change their mind and instead introduce the Person interface (in .NET land they’d create IPerson) to represent the Person as an abstract concept.

interface Person {
   public String getName();

Not a big change, so seems reasonable.

3. In Java they’d declare the setters/getters in the Person interface, then create a concrete class for Person, calling in something like PersonImpl.  (In the Coherence Engineering group we’d call it something like DefaultPerson or SimplePerson).

4. Now that they have an interface, the question arrises “how should you create an instance of a Person?”. That is, although we have the PersonImpl class, “we should not expose that to the core of the application, so we need a way of hiding creating instances”.  (Unfortunately most languages don’t allow overriding the behavior of “new” like this “new <interface>”. It would be great if you could tell the compiler, hey if you see “new Person” I actually mean “new PersonImpl”).  Anyway, to solve this problem and keep the code “pluggable”, they decide it’s time to use the “Factory Pattern” or potentially the “Builder Pattern” to create Person instances.  Hence the PersonFactory is born.

5. But… what if we need to replace the Factory?  Ok… easy… “just introduce a PersonFactory interface, and then introduce a PersonImplFactoryImpl class to create the Person instances as we need them”

Can you see how the names are starting to sound strange/ridiculous?  What once was a simple problem to solve, has now blossomed into the Person framework.  The names are starting to look ridiculous and to me, this gives the first indication of over-genericizing.

SIDE NOTE 1 (revisited): It’s very possible that something like this may actually be needed, but more often than not, it’s pretty rare.  Sometimes you just can’t simplify something that is intangibly complex.

SIDE NOTE 2: This is not over-engineering.  Over-engineering occurs when you make a product unnecessarily stronger or more durable.  The above does not increase strength (performance, availability, reliability or scalability).  It increases flexibility for the future and often a requirement that no one demands up front.

But we’re not finished yet.

6. The last and often ugliest of all steps is to consider how to create instances of the PersonFactory interface.  And you guessed it… it’s time for another factory, the PersonFactoryFactory interface.

Of course this sounds even more ridiculous, so it often becomes the PersonFactoryService 😛

So what went from a simple Person class and using the new operator to create instances, we now have a completely generic pluggable Person framework requiring the Person, PersonFactory and PersonFactoryFactory interfaces (an SPI if you like), together with the PersonImpl, PersonImplFactoryImpl and PersonImplFactoryImplFactoryImpl classes (to be completely correct)… just to say person.getName() and person.setName(…).

SIDE NOTE 3: I’m guessing you could simplify the factory names to PersonImplFactory and PersonImplFactoryFactory, but it’s not much better.

With this simple example it’s easy to see why inversion of control (IoC) has taken off.  In any system with 5 or 10 artefacts like this the complexity of wiring together an application is so great that it’s hard to know where to start…. and why?  All essentially so we can get back to saying something like “new Person”, but without being committed the Person implementation. No wonder we have the term “plain old java objects” (POJO), just to tell people “you can use the new operator on this class”.

Are we crazy to continue to build systems like this?  Isn’t OSGi (et al) making this any easier?  Spring has tried to, but even it’s download and dependencies are getting massive.

Perhaps the world is no longer as simple as it use to be, wants to be or needs to be.

There is help though… If you’re stuck for a class/interface name, you should check out

PASSING NOTE: The Java Beans specification and thus the introduction of the term Bean (essentially to mean a Object with getters and setters) often makes naming things even more ridiculous.  While I really like the Bean spec, it can be brutal on class names.

Person -> PersonBean
PersonFactory -> PersonBeanFactory (or PersonBeanFactoryBean)
PersonFactoryFactory -> PersonBeanFactory (or PersonBeanFactoryBeanFactoryBean)