Unforgettable: the eleven-year story of Javas caching API

JSR 107 is 90% complete says Greg Luck, spec co-lead and creator of Ehcache – its only taken since 2001.

In the
world of software development, plenty of community efforts end up
lost and abandoned. In contrast, it’s far rarer to see a dormant
project get back on its feet.

JSR 107, a
specification proposal for a Java caching API, has managed to beat
the odds.

Originally submitted a decade ago, the JSR has found new life in
the hands of Terracotta’s Greg Luck and two Oracle employees, and
is now close to inclusion in Java EE 7. It specifies a standard for
Java caching, allowing it to be easily added to products and
frameworks and for these implementations to be pluggable by
users.

Such a spec is particularly important for large banks like Goldman
Sachs, co-lead Luck told JAXenter, as they tend to use multiple
vendors’ datagrid products. “[If] you’re using three or four
proprietary interfaces, you have a desire for
standardisation.”

JSR 107 is hardly the first specification to find itself high and
dry. Recent data
compiled by Markus Eisele showed that there are currently
almost as many dormant and inactive JSRs as there are active ones
(9% and 13%, respectively). Taking eleven years to be finalised,
however, is fairly unusual.

The JSR was originally submitted by Oracle staff, with Jerry
Bortvedt as spec lead, in March 2001. “I’m not entirely sure why it
didn’t progress when it first started,” Luck told JAXenter.

In 2003, Cameron Purdy, then working at Tangosol (and now Vice
President of Development at Oracle) took over as spec lead, but
again the spec remained unfinished as, according to Luck, Purdy was
“basically too busy”.

Luck himself became involved in JSR 107 when asked to implement the
spec into his open source project, Ehcache, by its commercial sponsors.
However, what he found wasn’t much use in its existing state.

“It was just a really, really early draft, and an incomplete first
bit of work had been done a long time ago,” he says. “So I created
the edge case implementation of it, which was pretty pointless
because it was incomplete and wasn’t a workable interface.”

Luck ended up joining the JSR’s expert group, and became co-spec
lead in 2007. However, much to his disappointment, the sponsor
decided not to pay him to work on the spec.

The story might have ended there, had Terracotta not bought out
Ehcache in 2009. With their business consisting mostly of cache
technology, the company were were “very interested in picking up
the API spec and continuing it”. Meanwhile Cameron Purdy, having
joined Oracle in 2007, now found himself with the time and
resources to get involved again.

Eleven years on, the spec is “90% complete in terms of technical
work”, says Luck, and Brian Oliver of Oracle has joined as a third
co-lead to help with the final stretch. “We are in this process of
refinement right now.”

But can a spec dating back so far still be relevant? Far from
obsolete, JSR 107 is “more relevant than ever”, says Luck, thanks
to the ‘big data’ craze and a push for in-memory data grids.
“Possibly, when [the spec] got created, it was just created too
early,” he says.

“I’ve read Gartner’s research on data grids, and they say that the
lack of a standard is the biggest inhibitor to further mass
adoption. I think it’s a very, very good thing to do, and it’s the
Java way. So I think the time is right now.”

Unfortunately, progress has been slowed somewhat by the Java
Community Process, says Luck. “What’s held us up for the bulk of
this year was the complications caused by there being two co-spec
leads. It just took a long, long time to get through the approval
process at Oracle, and when Oracle were ready to sign, we then kind
of ran it up the flagpole at Software AG [parent company of
Terracotta] and they have own approval process, which took couple
of months.”

All of which meant that the Early Draft spec, originally submitted
by Luck in February, was only accepted by the JCP in mid-October –
nine months later. “It’s bloody frustrating,” he admits. To be in
time for Java EE 7, they’ll need to submit the spec and reference
implementation by 17 January, “an achievable date”.

With the JCP in a period of reform, does he have any suggestions
for making the processing easier? “When we get done, maybe I’ll
feel like offering some advice!” he laughs.

However, there is light at the end of the tunnel. A number of large
companies have pledged to implement the spec, including Oracle,
JBoss, Fujitsu and Terracotta themselves, and the expert group
includes IBM, TmaxSoft, Bluestone Software and the Apache Software
Foundation as well as large banks such as Goldman Sachs.

With a feature pegged for the spring edition of Oracle’s official
Java Magazine, Luck admits that “we’re sort of talking about it as
if it’s done, it’s all in”. Still, while there may be some work
left to do, it’s the closest it’s ever been to completion in the
last ten years. By next year, the spec’s long journey may be just a
memory.