Every now and then I get asked to explain the differences between our projects and platforms. It's getting less and less these days, as most people now understand it. However, it does come up and it's worth repeating here. I was going to launch into my explanation, which is well rehearsed by now, but then someone reminded me that Rich Sharples did a great job of this last year on his own blog. If you're at all unsure about the differences between our projects and our platforms, then take a look.

However, there is one thing that I want to emphasise about this "split": everything we do in our platform work goes into the "upstream" open source projects. We don't keep anything back from the communities that help to create the projects. As Rich explains, our productisation processes push the project code through a set of very stringent processes, e.g., qualifying against a range of database drives, hardware platforms and operating systems, to which the communities may not have access or the time. Yes, it can take weeks or months for us to iterate through our processes to create the necessary quality, fixing code, applying updates that we, or the community, didn't realise were necessary originally, etc.

But once we're done and we are sure that the resultant product can be released, we make sure that the changes go back into the project source repositories. Of course it may not make sense for us to put them back into the trunk of the project, e.g., the project may have moved on to a new major release. And code changes the productisation engineers make often go back into the code for the community projects as soon as they happen, especially if they are major functionality bugs or security issues. Disenfranchising our open source communities is not something we've ever done, or considered and it's not something that we're going to start now!

Our platforms benefit from our community work. Our communities benefit from the platforms too. So what is the benefit of the support contract that Rich mentioned? Well, as he says, using EAP as an example:

"JBoss EAP is supported for 7 years and with every additional minor or micro release we further improve the performance, security and stability of the Enterprise Platform. We’ve now released 2 micro and one minor release of JBoss EAP – that’s about 150 top-level issues in total. While the issue rate will slow over time – we’ll still be in a position to fix issues and respond to new security threats in 2016.

All those fixes are made available upstream and will ultimately make there way in to upstream binary releases but what the upstream project can’t guarantee is that those fixes will be isolated from more substantial changes and improvements – community releases typically don’t distinguish compatible bug fixes from more intrusive changes that provide the innovation."

So if you're wondering whether or not we're still the home of open source, as I said last year, the answer is yes. We do everything in the open and we keep nothing back from our communities. I'm fairly sure many of our competitors cannot say the same thing!

So just what is JBossEverywhere then? If you've seen the video of my keynote then it should be clear. However, I want to go into more details here just for the avoidance of doubt.

What it is not is simply a way for writing thin client applications that access various JBoss components or services that are running elsewhere. It isn't a new framework for writing HTML5, JavaScript, GWT or native web applications. It may utilise these technologies to achieve a goal, but that goal is so much more.

As I said in the presentation, the underlying theme behind JBossEverywhere is ubiquitous computing. Now there is no way I can take credit for that concept: ubiquitous computing has been around for many years; I remember it being discussed by all of the big middleware and hardware vendors at the turn of the century, as the next big wave. Some people may be forgiven for thinking that it simply didn't turn out that way, but they'd be wrong. You only have to look around you to see that it happened (is continuing to happen every day.) We just take it for granted that technology is an implicit part of everything we do today, yet you only have to turn back the clock a decade to see how different it was. And go back 3 decades, as I showed in the talk, and you could be walking into an episode of the Twilight Zone!

But what has this impact of hardware got to do with anything I want to discuss here? Put quite simply, these devices are an area where middleware, and JBoss in particular, can play an important role. Just as the new wave of personal computers were thought of as constrained 30 years ago and often looked on with distain by those in the workstation and mainframe arenas, yet now they power a lot of enterprise computing, so too will go many of the devices we see around us today as being of limited utility.

Your mobile phone already has capabilities that would put to shame PCs of the 1990's. They have also quickly become critical to our day to day lives, moving from supporting basic games to complex B2B applications. These applications need enterprise capabilities, such as messaging and transactions. In fact I've believed this for over a decade, having made Arjuna run on an HP Jornada 720 in 2000, with the intent to take this further had HP decided not to junk Bluestone only months later! A lot of the work I've done in intervening years on extended transactions and end-to-end transactions has also been an offshoot of these thoughts.

But it's not just mobile phones. Due to the economics of scale, it's not far fetched to assume that sooner than you think your washing machine, car or even coffee pot, will have more raw processing power than workstations or laptops of years gone by. Being able to tap into these processors is something that will happen, security considerations not withstanding. In fact as I've said before, this is really where I think cloud will go (return). At the moment cloud, or at least public cloud, is little more than offshoring; useful yes, but not taking things far enough. The true cloud is the processors around us, and being able to use that cloud offers many advantages and opportunities. And once again, middleware will be useful there.

So JBossEverywhere is about defining middleware components and frameworks that can be used on these various devices. We should not expect people to reinvent the wheel, e.g., transactions, when there's a perfectly good wheel already out there. It'll mean developing new projects and pushing the envelope, but that's what we're good at. New frameworks that will combine adaptability, configurability, monitoring etc. to allow them dynamically cope with changing deployment environments so that the application doesn't have to (in many cases.)

I suppose another way of stating the goals of JBosEverywhere is Ubiquitous Middleware, or specifically Ubiquitous JBoss!

I'm just back from JBossWorld and JUDcon. Individually they were each fantastic events, with JUDCon proving to be the premier event for JBoss developers and JBossWorld the place to find out where the products are heading. But this year things were slightly different and I hinted at this a few days before the event: this time we showed everyone where the future lies for middleware in general and JBoss in particular.

I could go into details in this blog entry, but thanks to Max, Pete and others we have an unofficial video of my keynote that drives the message home. (What's that they say about pictures and a thousand words?) There will be an official recording soon and I'll update this blog when that's out. However, in the meantime I recommend that you shut off your email client, turn your phone onto silent, grab a tea or coffee, and take the time to watch not only the best keynote this year, but probably the best keynote ever at JBossWorld (as voted by people who have been with JBoss a lot longer than I!)

When you're finished let us know what you think and come back here to find out more details of what we have planned. The next few months and years are going to be a great time for R&D at JBoss. Get involved: there's a lot to do and it'll be fun!

Finally we will be running a series of articles, asylum podcasts etc. to cover in detail the demonstration that you'll see in the video. So much went into it that we simply could not cover in the time. If you want to know more then we will show you everything! And my thanks to the team, including Kevin, Manik, Mike, Sanne, Jason, Pete, Ales, Emmanuel, Jay, Wesley, Burr, Christian, Mircea, for their work on the demo and making concrete some of the things I've been talking and thinking about for years. We have such a high concentration of the best talent in the industry at JBoss!

So remember: JBoss Everywhere!! (And thanks to Bob for giving a succinct name to what I could only describe in pages of text!)

Onward!!