Last Friday, during JavaOne, Ari from Terracotta was so kind to receive me at their offices. Arrived there, I was very happy to see that both Jonas Bonér (AspectWerkz fame) and Eugene Kuleshov (ASM expert) were part of our meeting.

The purpose was to go over RIFE's continuations implementation and see if, using Terracotta's technology, it would be easy to make them clusterable without having to trouble developers with the burden of making everything serializable (and them probably getting it wrong).

First I did a quick practical demo of the benefits of continuations, so that we were all on the same page. It was nice to see the positive reactions when I demoed continuations debugging for a basic order workflow. The recently added step-back support (great for form-based back buttons) particularly grasped their interest.

We quite quickly delved into the actual implementation of continuations to find where we could hook in their Distributed Shared Objects magic. I really enjoyed talking about all this with people that actually understood JVM bytecode (and probably much better than me) and were experts in the ASM toolkit.

It turned out that RIFE's continuations implementation doesn't have to change one single bit and that Terracotta mostly just needs to configure their existing technology to make it a drop-in no-brainer solution for developers.

So the plan now is for me to finally update the standalone RIFE/Continuations library with the current state of the source code, change RIFE itself to use it, and provide a clear overview and unittests to Terracotta so that they can kick-off the effort for their part. In a couple of months I'm sure we'll finally achieve fault tolerant native Java web continuations with failover and great scalability.

Yay!

I just uploaded RIFE 1.5 Milestone 1. I decided to not go ahead with the final release since there are still some situations where stateful embedded elements don't work as they should (notably when you create an exit link from an embedded element to another embedded element).

You get a speed release during development with this release. Before, RIFE checked for every request if any of the site-related files had changed, to be able to reload the structure on-the-fly. This thus also meant for all the images, styles, ... (since RIFE is a filter). In this release, the reload check is only made once every 10 seconds (this is of course configurable and is only used when auto site reloading is active).

The other major new features of this release are:

• annotations support for element declaration (example)
• step-back continuations (example)
• stateful components (which you use submissions and reflexive datalinks)
• complete injection and outjection support for all element data (inputs, parameters, inbean, outbeans, incookies, outcookies, parameters, globalvars and globalcookies)
• two new examples: stateful counters (source), hangman (source)
• support for create RIFE applications without any XML (not even participants.xml)
• upgraded a lot of supported 3rd party libraries
• fixes to meta data merging

The full changelog is here:
https://rife.dev.java.net/files/documents/204/34790/ChangeLog

Hope you enjoy this beta release and please notify us should you run into any problems.

I created a RIFE group on the JavaOne EventConnect website.

If you're at JavaOne and want to chat about RIFE, feel free to join the group.

This is a nice way of structuring any informal meetings. We can also use it to share some examples and documents after we have met.

RIFE is present in two sessions at this year's JavaOne.

If you have ever wondered what our framework is about and how it relates to the other technologies out there, now is the time!

You can either attend the dedicated RIFE BOF and participate in an informal and friendly discussion about what makes RIFE special, or you can attend the RAD Web Framework panel discussion to also see what other newer frameworks are up to.

Should you be at JavaOne, but not be able to attend either session, feel free to contact me through the Sun Event Connect tool, we can sit down somewhere and have a little chat about RIFE.

If you can't make it to JavaOne, check out our conference agenda for other RIFE sessions, straight from the source.

These are the details of the BOF, and what you can expect:

Cutting-edge productivity with RIFE

About RIFE

RIFE is a full-stack, open-source Java web application framework, offering fast results with the promise of maintainability and code clarity. While many are attracted to RIFE for the productivity gains it offers, the framework actively tries to solve difficult problems with creative solutions that combine power and flexibility with comfortability. RIFE has pioneered many novel ideas in Java web application development, including: pure Java web continuations, run-time POJO-driven CRUD generation, scalable component oriented architecture, state handling without sessions, focus on REST as an application API, bi-directional logicless template engine, and the integration of a content management framework.

About this session

This BOF will be driven by the audience that's present. Various presentations can be given about a collection of RIFE concepts. If people are interested in an informal Q&A session, questions will gladly be answered and backed by relevant examples or real-world application demos.

This session can demonstrate how RIFE lets you cut corners when there's no need for a complex setup. You can see how trivial CRUD functionalities are instantly available and how they can completely be customized without the need of restarting your servlet container. The rich POJO-driven meta-data system can also be demonstrated as well as how it propagates and drives most of the framework's modules. If there's an interest, we can also develop a component from scratch and introduce the web engine, the template engine, the persistence layer and the content management framework with clear and concise examples.

Pre-requisits

Attendees should have experience with dynamic web application development and have at least an intermediate level of Java programming knowledge.