The spec time forgot

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

Elliot Bentley

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.

Inline Feedbacks
View all comments