New RIFERS blogs entries from Geert Bevin in category rife

Custom constraints and validation in RIFE

2008-01-29T17:52:51+0100

Joshua Hansen wrote a nice example of how to create custom meta data constraints and display dedicated validation error messages with RIFE. He also shows how easy it is to make RIFE/Crud display your validation errors for beans that use your custom constraints.

Read the article in the RIFE wiki.

RIFE BOF tonight at QCon conference in San-Francisco

2007-11-08T22:40:24+0100

In case you want to learn more about RIFE, ask questions, chat a bit about what you've done, share experiences, etc., feel free to come the the BOF tonight that I'm organizing during the QCon conference in San Francisco. You can find all the details here:

http://qcon.infoq.com/sanfrancisco/conference/

The address is:
Westin San Francisco Market Street
50 Third Street
San Francisco
California 94103

The BOF will be from 8:30pm - 9:30pm in the 'City' room.

We are also organizing a Terracotta BOF right before it, so if you're interested in that, you can come from 7:30pm - 8:30pm to the 'Stanford' room.

See you there!

Speaking at NFJS Europe : "Cutting-edge productivity with RIFE and Web Continuations"

2007-08-09T20:46:53+0200

I'm speaking at NFJS in London at the end of this month about RIFE and Terracotta. You can find the abstract of my session quoted below. The schedule looks very interesting and I'm excited that NFJS is finally taking place in Europe too.

If you're interested in going, you might want to click on the banner to the right or to use the promotion code NFJS-RIF660. This will give you a free Nintendo Wii with your registration (woohooo, I love my Wii!).

See you at NFJS Europe.

I also have another session about Terracotta in the real-world.

Cutting-edge productivity with RIFE and Web Continuations

RIFE is a full-stack, open-source Java web application framework, offering fast results with the promise of maintainability and code clarity. This session will review the novel ideas in Java web application development that RIFE has introduced to the development community.

Through a real-world demonstration of the development process with RIFE, learn how RIFE makes developing easier with features such as: instant reloads and centralized declarations, meta programming through constraints and meta data merging, run-time POJO-driven CRUD generation, bi-directional logic-less templates, automatic context-aware components, and the integration of a content management framework.

The second part will focus on state management, which has always been a complex and tricky part of web application development. Native Java web continuations simplify this and automatically allow you to create a one-to-one conversation between users and a web application. State preservation and flow control no longer need to be handled manually, bringing you back to the simplicity of single user console applications. Remember 'scanf()'?

Continuations will be introduced from general principles, followed by practical examples that explain how they benefit web application development and their frequent usage patterns. Finally, automatic and non-intrusive fail-over and scalability will be demonstrated through the integration with Terracotta.

Artima article : Distributed Web Continuations with RIFE and Terracotta

2007-08-08T20:23:11+0200

In this article, Jonas Bonér and me discuss how the RIFE Web framework helps you become productive and efficient in building conversational Web applications. Productivity with RIFE is in large part due to RIFE's unique approach to Web development—its use of continuations for conversational logic, and complete integration of meta-programming to minimize boilerplate code.

We also introduce you to Terracotta and it's JVM-level clustering technology, and show you how Terracotta and RIFE can work together to create an application stack that allows you to scale out and ensure high-availability for your applications, but without sacrificing simplicity and productivity. This means working with POJOs, and minimal boilerplate and infrastructure code.

You can read it at Artima.

Frank Sommers : What Do You Look For in a Template Engine?

2007-07-21T10:41:29+0200

Frank Sommers of Artima has started a discussion about template engines and asks what you find important in them.

Template engines seem to be one of the most stagnant technologies in Java, many adopt the design that mixes content and logic but implement it differently (PHP, JSP, Velocity, Freemarker, ...). It's a good thing that Terrence Parr (of ANTLR fame) created StringTemplate which seems to move in a similar direction as what we've been doing with our template engine in RIFE. He acknowledges the push model that injects values and text into a template instance instead of pulling them in with an expression language. While I prefer our approach where there really is no logic in the template at all, I really appreciates what Terrence says in his docs:

Language theory supports my premise that even a minimal StringTemplate engine with only these features is very powerful--such an engine can generate the context-free languages (see Enforcing Strict Model-View Separation in Template Engines); e.g., most programming languages are context-free as are any XML pages whose form can be expressed with a DTD.

This goes back to a less-is-more philosophy where you build what is needed to comfortably use a technology in trivial and advanced situations, and nothing more. RIFE's template engine does the same. Instead of including a whole collection of additional features, we rely on you making a mental shift to adapt your development habits towards the new capabilities and characteristics of our template engine. In my case its not language theory, but rather lots of very complex HTML layouts and other uses of our template engine that gets me to say that our template engine is powerful enough to allow you to comfortably build anything you want, without compromising on context separation and reusability.

Have you ever tried out another template engine besides the classic pull model in anger? What did you think of it?

RIFE 1.6.1 released

2007-07-14T23:40:41+0200

There are no new features since release 1.6, this is a bugfix release.

Everyone using continuations is urged to upgrade to 1.6.1 due to performance regressions that crept into the previous release.

You can read the full changelog for more details.

This release can be downloaded from the downloads section, as usual.

RIFE 1.6 released

2007-07-02T15:25:32+0200

Below are the highlights:

Isolated continuations package with proper public API and separately downloadable jars
Byte-code instrumentation agent that can replace the classloader
Integration with Terracotta for continuations fail-over and scalability
ManyToOne and ManyToMany relationships in the GenericQueryManager with lazy-loading
Refactored authentication package for optimal pluggability
New template tags BA and C
Template tag syntaxes don't require quotes anymore
MVEL as blockvalue scripting language
JRuby support for implementing elements
Support for the H2 database
Support for Java 5.0 enum types
ReadQueryString and ReadQueryTemplate query builders
EXIT:PARAMSJS:name and SUBMISSION:PARAMSJS:name for increased spammer protection

Full documentation for the new features is being written and will be published in the RIFE wiki cookbook.

You can read the full changelog for more details.

This release can be downloaded from the downloads section, as usual.

JavaOne Podcast : Web continuations with RIFE and Terracotta

2007-06-07T19:44:01+0200

The podcast of my mini-talk at JavaOne 2007 has been published on java.net, this is the abstract:

State management has always been a complex and tricky part of web application development. Continuations simplify this and automatically allow you to create a one-to-one conversation between users and a web application. State preservation and flow control no longer need to be handled manually, bringing you back to the simplicity of single user console applications. Remember 'scanf()'?

This presentation will introduce continuations from general principles, followed by practical examples that explain how they benefit web application development and their frequent usage patterns. Finally, automatic fail-over and scalability will be demonstrated through the integration with Open Terracotta.

You can listen to it here.

The corresponding slides and examples can also be downloaded.

RIFE and OpenLaszlo users get together at JavaOne 2007

2007-05-09T18:09:24+0200

I already bumped into some RIFE users on the conference floor and I thought it would be nice to at least set a time apart to have some drinks together and exchange war stories .

I propose that we meet today, May 9th at 17h30, at the Thirsty Bear. This is right before the JavaOne bloggers party, so you don't have to miss that. Maybe we can even spread the word about our favorite projects!

Even if you don't know open any of the projects in detail but are interested cutting-edge web development, native Java continuations, Rich Internet Applications, ... you're welcome to stop by for a chat.

If you don't know what I look like, here's a recent picture:

Re: Impressions of the RIFE framework

2007-04-10T22:49:07+0200

Atif Khan wrote a blog entry about his experience with RIFE. Sadly, the comment system on his blog seems to be broken, so I can't post a reply there. I'm thus posting it on my own blog.

Hi Atif,

thanks a lot for writing down your impressions, and you see that I did get to your blog entry

Here are my reactions to your 'cons':

Atif Khan:
Templates are really weird to work with. The syntax for the templates really did me. It is not really designer friendly like Tapestry or Wicket

Which template syntax did you use? If you want the designer-friendly version, you have several to choose from, like the comment based syntax and the real XML syntax. I suppose that this is a matter of being aware of them, which is not easily solved (there's a wiki page about them though).

Atif Khan:
The concept of flowlink and datalink is just too verbose and not clear

The flowlinks and datalinks verbosity are easily solved through different manners. They're like the finest grained possibility. For a lot of people, globalvars and globalexits are totally sufficient and only require one declaration. Another good solution is just to use autolinks, if you combine these with annotations, there's very little setup to do for the logic flow and data flow to work.

Also, if you think they're not clear, this page in the users guide might make it easier to understand: http://rifers.org/wiki/display/RIFE/GuideNumberguess.

Atif Khan:
Using annotation didn’t do me any good as well for defining the flow and data links. There isn’t enough documentation for annotations.

I agree that the documentation here is lacking, but annotations are a recent addition, so in time it will get better. The best thing usually is to try to combine what's on the wiki with the javadocs and the examples. For the annotations, there's some kind of overview here: http://rifers.org/wiki/display/RIFE/Best+Practices. You can also have a look at the javadocs for them.

Atif Khan:
The only way for form validations I could find was to define the a MetaData class equivalent to the domain object representing the form and define the validations in there. This just seems like way too much of work for simple validations.

Atif Khan:
I could not figure out how to customize the error messages for form validations

It's a pity that you didn't see the real value of the validation framework, the MetaData classes actually generate the statements for the real validation framework underneath, which is totally customizable. Several times I've heard users say that they found RIFE's validation framework to be the most flexible and powerful one that they've come across. Information about that can be found here: http://rifers.org/wiki/display/RIFE/Validation, this also contains instructions about how to customize the error messages in many ways. The javadoc for the Validated interface might be helpful too. You can basically create any ValidationRule or ValidationError that you want, using MetaData just automates it all.

Please don't hesitate to tell me where you find holes in the documentation. I think that a lot of it is documented, it's mainly an issue of finding the right content. Shooting of a message to the mailing list will often get me or someone to point you in the right direction. There were some books in the writing, but sadly I had to cancel them due to time constraints. There might still be some coming up in half a year or so, but it really is very bound to my availability.

Again, thanks a lot for making the effort to look at RIFE, I know that it's a lot to digest.

JavaPolis Podcast : Web continuations

2007-03-05T17:59:40+0100

The recording of my talk at JavaPolis 2006 about Web Continuations has been made available as a podcast.

You can listen to it on Parleys.com or subscribe to their feed to have all the JavaPolis audio content delivered to you.

Note: please, each time I say 'Josh' mentally substitute it for 'Neil' ... I made a horrible mistake and people only pointed this out to me after the talk, I sank into the ground from shame

Why consider the RIFE framework - excellent testimonial on TechRepublic

2007-03-02T19:46:51+0100

David Spector wrote an extensive blog entry on CNET TechRepublic about why he selected RIFE to develop his web-based business applications.

If you've been wondering why you should bother to look at RIFE, this is a nice overview.

The part where he talks about the 'UNlearning curve' is very true ... I've witnessed it many times.

Read it here.

Continuations interview on Artima Developer

2007-03-02T09:37:25+0100

Bill Venner from Artima Developer has interviewed me at JavaPolis 2006.

Originally this was intended to be posted as an MP3 together with the other interviews (day 1, day 2, day 3), however we went on for almost an hour instead of 15 minutes. Frank Sommers took the trouble of transcribing and editing the interview and posted it today on Artima Developer.

If you're still wondering what continuations are about or want more in-depth information, head over to the article.

MVEL support in RIFE templates

2006-12-29T13:48:09+0100

A couple of years ago I planned writing a very small boolean expression language for usage in RIFE. None of the existing ones really felt like a good fit, but I ended up adopting OGNL, Groovy and Janino anyway due to lack of time. What bothered me most about these is that they are too powerful for their intended purpose and that users could potentially stuff too much logic inside templates.

Expression languages in RIFE are only used to conditionally assign the content of a template block to a value. This allows you to easily show certain parts of the interface depending on, for instance, the role of the user, an application-wide configuration parameter, another template value, etc. The only function of the expression language is to evaluate short conditions that result in true or false, thus meaning: should this block be assigned to the value or not.

Come MVEL, I saw it being mentioned on the Groovy IRC channel yesterday and had a look at it. It seems that the language supports exactly the feature set that I wanted to implement for our own expression language. MVEL can be very easily integrated and supposedly performs better than the rest. It is still lacking real-world testing by a large user community though and I stumbled into a series of minor issues with it. Chris Brock, the developer, is very responsive and seems extremely passionate about resolving problems as quickly as possible.

Today I committed MVEL support to the RIFE subversion trunk and will most likely be advocating it as the best choice for our blockvalue scripting feature as of RIFE 1.6.

I'm even wondering now if I should not integrate MVEL entirely inside the core RIFE distribution jar, as I've previously done with ASM and PCJ. This would mean that blockvalue scripting will be available to anyone without having to figure out which jar file they need for it.

Any thoughts on that?

RIFE : 2006 Java Tech Winner (Honorary mention)

2006-12-27T14:07:05+0100

RIFE was included as a honorary mention in a 2006 Java technology winner list at O'Reilly for the Java Web Framework/API category. With the de-facto standard JSF being the absolute winner in that area, this is awesome news and shows that our efforts are being noticed and appreciated.

It's also interesting that Groovy is included in this list. Not many people may know this, but RIFE has been a huge Groovy supporter for many years. It is a first-class scripting language for our framework. For example, you can write the entire website configuration or domain model in Groovy and have it reload at run-time, or use it as a boolean expression language inside templates. Of course, your server-side components can be also written with Groovy and even seamlessly integrate with other JVM scripting languages or regular Java in the same web application flow.