OcpSoft » Java

How to JSF 2.0: – render components outside of the form

Lincoln — Mon, 10 May 2010 04:48:00 +0000

Here’s a simple tip for all of you AJAX lovers using JSF 2.0. It is possible to render components that live outside of the form where your AJAX tag lives; actually, it’s possible to render any component by using it’s fully-qualified component ID.

Just prefix the target ID with the naming-container separator character, usually “:”, and provide the full name of the component as it is rendered on the HTML page.

 execute="validatePasswords password @this" render=":messages" />

Your component ID would look something like, :namingContainer:myComponent. Where the first “:” tells JSF that you want to start looking for the component at the UIViewRoot instance, or the very top level of the component tree.

Here’s a more full fledged example:

 xml:lang="en" lang="en" xmlns="http://www.w3.org/1999/xhtml">
 id="messages" globalOnly="true" />
 
>Select a username and password>
 id="registerForm" prependId="false">
	 id="username" value="#{registerBean.username}" required="true" />
 
	 id="email" value="#{registerBean.email}" required="true" />
 
	 id="password" value="#{registerBean.password}" required="true"/>
	 id="validatePasswords" fields="password1=password password2=passwordConfirm" validatorId="passwordConfirm" />
 
	 id="passwordConfirm"
		value="#{registerBean.passwordConfirm}">
		 execute="validatePasswords password @this" render=":messages" />
	>
 
	 type="submit" id="submitRegister" action="#{registerBean.doRegister}" value="Create my account" />
>
>

Notice how the AJAX tag references the “:messages” component outside of the form – it’s as easy as that!

 execute="validatePasswords password @this" render=":messages" />

As an extra treat, this form is also using the multiple-component validation feature from Seam, otherwise known as Cross-field validation, or XVal.

That’s all for today — enjoy, and as always. Happy coding!

JSF 2.0 Cross-field Form Validation – Simple in Reality

Lincoln — Wed, 05 May 2010 14:55:50 +0000

I’d like to start by saying that using JSF by itself can sometimes feel trying to pull your own teeth out with a pair of tweezers, but there’s hope. JSF was designed to be a platform of extensions – a foundation for building web-frameworks, and that it’s done very well. JSF 2.0 addresses most of the concerns about usability (so there’s less tooth pulling,) and provides even more extensibility. That’s where Seam Faces comes in, that’s where PrettyFaces comes in.

On many occasions you might find yourself needing to compare the values of multiple input fields on a given page submit: confirming a password; re-enter password; address lookups; and so on. Performing cross-field form validation is simple – just place Seam’s component in the form you wish to validate, then attach your custom Validator.

I’d like to introduce you to Seam’s intuitive answer, taken directly out of the reference manual. If you want to try it out, you can check out the source or use a snapshot:

        >
            >org.jboss.seam.faces>
            >seam-faces>
            >${seam-faces-version}>
        >

Seam Faces’

 id="locationForm">
      id="city" value="#{bean.city}" />
      id="state" value="#{bean.state}" />
      id="zip" value="#{bean.zip}" />
      id="submit" value="Submit" action="#{bean.submitPost}" />
 
       validatorId="locationValidator" />
>

The corresponding Validator for the example above would look something like this:

@FacesValidator("locationValidator")
public class LocationValidator implements Validator
{
   @Inject
   Directory directory;
 
   @Inject
   @InputField
   private Object city;
 
   @Inject
   @InputField
   private Object state;
 
   @Inject
   @InputField
   private ZipCode zip;
 
   @Override
   public void validate(final FacesContext context, final UIComponent comp, final Object values) throws ValidatorException
   {
      if(!directory.exists(city, state, zip))
      {
         throw new ValidatorException(new FacesMessage("Sorry, that location is not in our database. Please try again."));
      }
   }
}

Tip – You may inject the correct type directly.

@Inject
@InputField
private ZipCode zip;

Notice that the IDs of the inputText components match the IDs of your Validator @InputFields; each @Inject @InputField member will be injected with the value of the form input field who’s ID matches the name of the variable.

In other words – the name of the @InputField annotated member variable will automatically be matched to the ID of the input component, unless overridden by using a field ID alias (see below.)

 id="locationForm">
      id="cityId" value="#{bean.city}" />
      id="stateId" value="#{bean.state}" />
      id="zip" value="#{bean.zip}" />
      id="submit" value="Submit" action="#{bean.submitPost}" />
 
       fields="city=cityId state=stateId" validatorId="locationValidator" />
>

The field with ID “zip” will still be referenced normally; you need only specify aliases for fields that differ in name from the Validator @InputFields.

Tip – Using @InputField

Using @InputField("customID") with an ID override can also be used to specify a custom ID, instead of using the default: the name of the field. This gives you the ability to change the name of the private field, without worrying about changing the name of input fields in the View itself.

@Inject
@InputField("state")
private String sectorTwo;

A few last thoughts

First, as of the current version, cross-field validation does not work unless you are using the component. As soon as a new version of weld-extensions is released, however, this functionality will work even without the component, and you’ll be able to reference cross-fields in any JSF validator!

For right now, however, you’ll have to deal with using the component – but – it’s really not that complicated if you think about it Happy coding!

Seam Faces 3.0.0.Alpha3 – JSF 2.0 just got even easier!

Lincoln — Fri, 23 Apr 2010 20:16:27 +0000

Ever wondered why JSF doesn’t support bean @Inject-ion in Converters or Validators? Ever wondered how to listen to a single PhaseEvent or ComponentSystemEvent, or filter on events by componentId, or view? Ever wondered why you can’t just @Inject FacesContext, or NavigationHandler?

Well… now you can, with the brand-new, just-out release of Seam Faces — 3.0.0.Alpha3

>
 >org.jboss.seam.faces>
 >seam-faces>
 >3.0.0.Alpha3>
>

(Currently only available through Maven)

Sample some features:

Focused on harnessing the power of Weld/CDI for Java, Seam Faces 3.0.0 has a good deal to offer, and more is in the works. Take a look below to see some of the powerful new functionality you’ll be able to deliver with your JSF 2.0 application. (View the latest user’s guide.)

No more statics!

With Seam Faces, you’ve got no more statics! Unit test with ease. Seam Faces breaks the static FacesContext.getCurrentInstance().getExternalContext() anti-pattern by producing these artifacts for easy @Inject-ion.

public class ExampleBean {
	@Inject ExternalContext context;
	@Inject FacesContext context;
	@Inject NavigationHandler handler;
}

Now unit tests can draw upon a mock faces context, such as:

@RequestScoped public class MockFacesContext extends FacesContext {
    // mock stuff here
}

This works perfectly, for example, if you were using JBoss Arquillian (the future of integration testing) to do real in-container testing; your test setup would look something like this.

Converter/Validator Injection:

By default, JSF treats Converters and Validators like “dumb objects.” It creates and throws them away whenever it pleases. With Seam, you can take back control of these artifacts. Take the following example converter, for instance:

As you can see below, this class is SessionScoped, meaning the user will retain the same Converter for the duration of the session. In other words: this converter is stateful. It supports @Inject! Not only that, but you can register interceptors and decorators on JSF Converters/Validators. They are beans just like any other CDI-managed object!

Note: If you do not @Scope your converter/validator, it will not be stateful, and the only enhanced support will be @Inject. @PreDestroy and @PostConstruct lifecycle callbacks will not function – the bean is not managed by CDI, only injected.

@SessionScoped
@FacesConverter("authorConverter")
public class AuthorConverter implements Converter
{
   @Inject
   FacesContext context;
 
   @PostConstruct
   public void setup()
   {
      System.out.println("AuthorConverter started up");
   }
 
   @PreDestroy
   public void shutdown()
   {
      System.out.println("AuthorConverter shutting down");
   }
 
   @Override
   public Object getAsObject(final FacesContext arg0, final UIComponent arg1, final String name)
   {
      System.out.println("getAsObject - Context is: " + context);
      return new Author(name);
   }
 
   @Override
   public String getAsString(final FacesContext arg0, final UIComponent arg1, final Object author)
   {
      System.out.println("getAsString - Context is: " + context);
      if (author instanceof Author)
      {
         return ((Author) author).getName();
      }
 
      return "";
   }
}

PhaseEvent Observers

Let’s say you want to observe a JSF PhaseEvent. Now, instead of registering an entire PhaseListener class in faces-config.xml, simply create an observer method!

public void observeBefore(@Observes @Before PhaseEvent e)
{
	// Listens to all phases, before the phase
}
 
public void observeAfter(@Observes @After @RenderResponse PhaseEvent e)
{
	// Listens to the RenderResponse phase, after the phase
}

This gives us an incredible amount of control when listening to specific phases. We no longer have to write boiler-plate code to determine which phases your listener cares about, just filter using @Annotations!

Additional Scope Annotations:

JSF 2.0 introduced the concept of @javax.faces.bean.ViewScoped and @javax.faces.bean.FlashScoped, but only provided an annotation for the View Scope!

Seam Faces goes the extra mile, and provides the @FlashScoped annotation, which means that a bean in this scope will be stored in the JSF Flash. @ViewScoped means that the object will be stored in the UIViewRoot, unique for each JSF View/Page.

That’s all for now.

There are more features, and more that are coming, but for now — that should get you started Try it out; get involved with the project; tell us what you think!

PrettyTime 1.0.6 Released – New Languages, Thread-Safety

Lincoln — Tue, 20 Apr 2010 16:03:45 +0000

OcpSoft PrettyTime is an open-source time-formatting library for creating human-readable timestamps like, “in 3 minutes,” or “moments ago.” — intuitive, easy, extendable. Visit the home page to download and learn more about using PrettyTime. New features in this release: Thread Safety, Java 1.5 compatibility, extra languages.

>
	>com.ocpsoft>
	>ocpsoft-pretty-time>
	>1.0.6>
>

New Features:

Several new languages are supported out-of-the-box in Version 1.0.6:

Slovenian – Uros Majeric
Bulgarian – Марио Георгиев
Italian – Mirco Attocchi
See all supported languages or submit a new translation!

Thread safety:

In addition to new translations — PrettyTime 1.0.6 is now Thread-Safe (why you would want to share a PrettyTime object is unknown to us, but now you can do it with confidence.)

Java Version 1.5 support:

PrettyFaces had erroneously been “updated” to require Java 1.6; it is now Java 1.5 compliant once more, and can be used on all of your favorite JVMs.

Example:

A quick intro to PrettyTime using JUnit:

public class PrettyTimeTest
{
 @Test
 public void testMinutesFromNow() throws Exception
 {
    PrettyTime p = new PrettyTime(new Date(0));
    assertEquals("12 minutes from now", p.format(new Date(1000 * 60 * 12)));
 }
}

Using Embedded Glassfish with Maven

Lincoln — Tue, 23 Mar 2010 18:12:06 +0000

Three steps to add Embedded GlassFish to any existing project POM. (Upcoming – Part 2: Using Embedded JBoss AS with Maven)

Using Embedded Glassfish

The Embedded Glassfish project is hosted on java.net, and as it is described, is very simple: “This project develops APIs and tools around “embedded GlassFish v3″. Embedded GFv3 is a delivery vehicle of GFv3 so that applications and tools can use GFv3 just as a library, inside their JVM, instead of having GFv3 as the overload of the entire JVM process. (And no, embedded GFv3 is not meant to be run on JavaME.)”

1. You’ll need to add this plugin repository to your POM:

        >
		>
			>Glassfish>
			>http://download.java.net/maven/glassfish/>
		>
	>

2. Then add the following plugin to your POM:

          >
                 >
			>
				>org.glassfish>
				>maven-embedded-glassfish-plugin>
				>3.0>
				>
					>glassfish>
					>test.war>
					>8080>
					>test>
				>
				>
					>
						>install>
						>
							>run>
						>
					>
				>
			>
                >
         >

3. Commands

embedded-glasfish:run – starts the embedded server if it is not already running and deploys the specfied application. The goal keeps the server running, so the user can make changes in the application, reploy and test iteratively.
embedded-glassfish:start – starts the embedded server with the specified parameters
embedded-glassfish:deploy – deploys the specified application
embedded-glassfish:undeploy – undeploys the application identified by the “name” parameter. If no name is specifed all applications are undeployed.
embedded-glassfish:stop – stops the embedded server
embedded-glassfish:admin – executes the specified admin command on the embedded server. For example, you could create a jdbc resource.

Reference:

http://blogs.sun.com/sirajg/entry/using_maven_plugin_for_v3

Why doesn’t (JPA, JMS, JTA, EJB, JSF, CDI) work? JEE is “Too Complicated”

Lincoln — Wed, 17 Mar 2010 16:53:27 +0000

First, before reading this – you’re going to be upset with me. You’re going to disagree. I know — it’s OK. You may not even believe me, but you might keep reading because anger inspires action.

Stop using Tomcat and wondering why JEE “doesn’t work.”

You’re doing yourself a big disservice.

Start thinking about JBoss AS 6, or GlassFish v3 — Yes, I know, it’s a “Full JEE Container,” — it’s “Heavy,” but with JEE6, that’s not a bad thing: It all “Just works” and it works really well. Trust me, the reason people have thought Java EE sucks, is because they try to do this stuff on Tomcat, and say “Why doesn’t (JPA, JMS, JTA, EJB, JSF, CDI) work?” Well… that’s because Tomcat only gives you Servlet – the Request/Response lifecycle. So people install all these things manually, or try to, and then say, “Wow, Java EE is really hard to use, shit, I’m gonna use Spring or Grails instead.”

Tomcat, Jetty, and other “Servlet Containers” all have these issues – that’s why they are called Servlet Containers. If you really want to build everything from the ground up, piecing in parts of Java EE here and there — then go for it, but if you want it to work right away, then… well, I’ve said my part.

Ever tried to use Java Mail on Tomcat? I think we’ve all been there… you need to steal the JAR from another appserver, or get a 3rd party implementation. Sure, it’s easy, you can do it… but why should you have to?

Please remember when submitting flames: I do know that there are a lot of legitimate reasons to use Tomcat, it’s a great Servlet container. If that’s what you choose, good for you, I think you’re wasting time if you’re trying to get bits of JEE to work, though.

In my experience.

I wrote a fully functional JSF 2 application in 5 minutes. I created a new web project (Maven, Jboss Tools eclipse plugin (For easy JBoss AS 6), Netbeans, glassfish eclipse plugin, whatever) I created an index.xhtml file, and I was running JSF. Wow, that was easy, right? I even installed PrettyFaces and had Pretty URLs and URL Rewriting working in about 2 minutes – i recorded a video, only minor edits.

My WAR file was 5kb — yes, Kilobytes.

Now I wanted to use CDI and EJB – I made a Cron-like scheduler – idea taken from Adam Bien‘s JEE Patterns example – that sent email notifications to (nobody) “Subscribers:”

@Singleton
public class SubscriberNotifier {
 
 private Date started = new Date();
 
 @Schedule(second="*/30", minute="*/1",hour="*", persistent=false)
 public void sendNotifications()
 {
 System.out.println("Notifying users subscribed to posts. First notification sent: "
 + new PrettyTime(new Date()).format(started));
 }
}

I did use PrettyTime to format the date object into something human-readable, but that’s not really relevant to JEE. The point is - I had a background service running, using EJB Scheduling – with full transactional and persistence support (if I chose to use those) up and running in as little time as it took to write a dumb little class and put two annotations on it. The JEE container automatically picked it up, and started it when I started my application.

And then I thought, “Wait, when did this get easy?” EJB used to make my heart shrivel inside my chest.

It’s all going to get even easier, too, when JBoss Seam 3 Framework starts releasing more of our development modules. I’m working on the Faces, Servlet, and Internationalization modules personally.

Now that my elevator speech is over If you already use JSF 1.2, now is the time to upgrade — migrating to JSF 2.0 should be pretty simple. All you need to do (unless you use some 3rd party component libraries) is change your XML schema in faces-config.xml, version from 1.2 to 2.0.

xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance”
xsi:schemaLocation=”http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-facesconfig_2_0.xsd”
version=”2.0″>

And you will be running with JSF2. Once you do that, you should definitely try out CDI (Weld) – it’s IMPRESSIVE. Trust me… if you’ve tried, or heard of Spring – you’re going to like this. PS. You can also get use the plug-in for JBoss AS 5 for JBoss AS 6; get it the via “Install additional server adapters” link in Eclipse’s “New Server” dialogue.

Final thoughts:

Note: As a followup, I’d also like to add that the JCP – “Java ‘Corporate’ Process” really needs to be re-evaluated. It needs to be placed in the hands of the community in which it was supposed to stand for so long. Oracle has this chance – and it must not blow it if the good things we all love about Java, JavaEE, the JVM, Tomcat, Grails are going to continue moving forward with healthy competition and innovation.

I call for the JCP – “Java Community Process” to become an independent foundation like Eclipse – public TCKs, free intellectual property, true community participation (open mailing lists, forums, wikis) – WITHOUT the need to print and fax a 7 page JSPA document to Sun in SanFran. I’m calling for a place where Java and JavaEE documentation are provided to, and by, the community – a site like PHP.net. I’m not the only person asking for this. Oracle – I’m holding you accountable for the future of Java, JavaEE, and the JVM.

In the words of the human torch…

“FLAME ON!”

One year’s time

Derek — Thu, 28 Jan 2010 17:53:39 +0000

It is amazing what can be done in exactly one year’s time. January 17th will have been the 2nd anniversary since Lincoln Baxter and I started OcpSoft. It’s been one seriously fun, and wild, ride with JavaServer Faces and the open-source community. I want to take a moment to talk about my partner’s success story and what he has accomplished in just one short year.

The Beginning

When we started OcpSoft, we were working on what is now ScrumShark – using JSF 1.2 , Hibernate, and many other technologies. At first it was very overwhelming, challenging to figure out which technologies to use; though, even after we had chosen our technology stack, we fought with poor documentation, lack of support, and integration as we explored new features of the stack.

During that time Lincoln saw a need for pretty URLs, because what was currently on the market wasn’t intuitive, and was painful to work with. The enhancements we requested weren’t getting approved or were too slow coming, even providing patches. So Lincoln set out to do it himself, and as he puts it: “destroyed Thanksgiving 2008.”

PrettyFaces

Thanks to PrettyFaces, Lincoln dug-in to JSF and started to really understand the inner workings of both problem and solution; within a few weeks of releasing version one, we were seeing many supporters. Soon after, Lincoln was contacted by Dan Allen from JBoss/Red Hat, and started assisting him with an enhancement to JSF’s navigation system.

During that same time Lincoln convinced us – at OcpSoft – to start using JSF 2 Beta to build ScrumShark. JSF 2 was undergoing continuous changes at that time, and the specification wasn’t even public, so we were seeing different results in our application every week. Lincoln started posting the issues on the JSF 2 mailing list, and quickly became known as the JSF 2 tester, bug-finder. Without ScrumShark, and Lincoln willing to take a chance on a bleeding edge technology, I don’t think the JSF 2 team would have found and fixed all the bugs as fast as they did. Not too long after this, he joined the JSF Expert Group and was presenting PrettyFaces at JSFSummit.

Congratulations Lincoln!

He just got a job with JBoss at Red Hat, as a Senior Software Engineer. I am proud of of what my partner and best friend Lincoln has accomplished.

JSF 1.2 Components (Book Review)

Lincoln — Wed, 20 Jan 2010 06:56:21 +0000

As a vocal blogger, I feel responsible for promoting and sharing the good work of others, whether that be technology, creative work, or in this case: a book. I will take no exception to that philosophy when it comes to the JavaServer Faces framework. For a quick read, try the summary. If you are intrigued, read on! I hope you find this review valuable.

In summary: I would recommend buying this reference if you are a consumer, designer, UI-developer who is working with existing component libraries, Facelets or JSF 2.0, and not so much focused on creating custom Java-components of your own. I don’t, for every-day web-site components, see why you would need much more than what is featured between the covers of this book. Ian Hlavats does a fantastic job of making bringing JSF to the everyday development setting.

JSF 1.2 Components

By Ian Hlavats

Download Chapter 2: Facelets Components as a PDF

In detail:

Initially hesitant to buy a reference on components, I have to admit that I was surprised to learn so much by reading through this book. As a member of the JavaServer Faces 2.0 expert group, and a full-time software engineer, components are not my strong-suit. If you’re at all like me, then you’re probably asking yourself the same question I did:

“What can I learn in this book that I can’t find on Google? JavaServer Faces has a huge online community, and there’s a lot of information available already.”

It’s a valid question, but you should keep reading because this book offers something important that I rarely find in blog entries or wikis: “features you wouldn’t think to look for; features that you wish you’d thought of, or don’t know how to make yourself.” I wish I had found this book when I started using JSF, because I’d probably have been more comfortable, and much more productive with our component side of the life-cycle, so to speak; I discovered features of the framework, and pre-made UI-tools that I wish I’d known about years ago.

Things you’ll learn about:

Modal windows, menus, wizards and workflows, AJAX anything with Ajax4JSF, i18n and localization, gCal-like schedules with Apache Tomahawk, multi-field validation, calendars, charts and graphs, file-uploads, user permissions/security, skinning, styling, and all major component libraries are covered in this book (save PrimeFaces, which gets a mere mention.)

If you think you’re looking at “Just another book on JSF component writing,” that’s not entirely the case. This book provides real solutions, real examples on how to get started writing JSF applications using existing component libraries and plug-ins. There are two types of chapters in this book: tutorials and references. The tutorials will get you up and running with a quick example, while the reference sections go in depth on usage of individual components within each library.

You’ll also (as a bonus, in my opinion) get some appetite-whetting information on the JBoss Seam framework, which is a user-friendly and business-oriented extension to the Java EE technologies. I didn’t get a very good picture of all of the concepts until I actually looked at the code samples (downloadable here, or just follow the link in the preface,) but that’s hardly a strong criticism; though, it may have helped if the code samples were more explicitly, frequently referenced.

In the end “The title doesn’t lie”:

I haven’t seen a more comprehensive book on component libraries and component writing made available to date.
JSF2 component writing has been simplified, but if you want to supplement your app with everyday things like in-place editing, accordions, and more, you’re going to want good examples; this book provides examples in abundance (even examples of JSF2 EzComp, which is a dream to use. UI like it was meant to be)
Even if components and UI design are not your strong-point, that is exactly why you should read this book; it makes component-based design easy to understand, and easy to implement.

The author covers many of the advancements in component writing and simplified configuration that are provided by JSF 2.0, but I would have liked to hear some information on the component behaviors model, and mention of integration with frameworks like CDI (JSR-299) and Spring; however, this is not entirely relevant to component writing, and plenty of information exists on sites like www.javaserverfaces.org or Google.

My one complaint is that for a book titled “JSF 1.2 Components,” it did not explain, or teach me how to create custom Java-based components, which are essential for complex behavior and interaction at some level. JSF 2.0 has done a good job of making Java-based components unnecessary, but this book is titled JSF 1.2 components, thus, I would have liked to see how to write a Java-based component in JSF 1.2.

JSF 1.2 Components on Packt Publishing
Download Chapter 2: Facelets Components as a PDF

End notes:

Make sure you check out www.javaserverfaces.org. It’s a great starting point and reference for JSF that you will undoubtably bookmark if doing a lot of work, and doing the work with this book. Also check out http://ocpsoft.com/prettyfaces/ for more information on Pretty URLs in JSF, and building client-facing JSF web applications.

What a wild ride – My journey through OpenSource / JSF

Lincoln — Sat, 19 Dec 2009 23:21:47 +0000

It was about one year prior to this article that I wrote “JSF2 is in good hands”, in which I spoke about the upcoming release of JavaServer™ Faces 2, and how the community had changed immensely in the few years I’d been using the tool. There were changes I wanted to make, and started making them by publishing an open source extension called PrettyFaces.

PrettyFaces lets you map Pretty URLs to any resource within a JSF-based web-application (eg: /example -> /faces/examples/page.xhtml). While this is stuff that other web-frameworks have been doing for years, (WordPress, Rails/Grails, etc) it’s stuff that has traditionally been hard using JavaServer Faces – until around November 2008, when the first release was published.

Now, I’m relatively new to this arena – I entered the open source community for the first time about four years ago, working on PHP and Perl modules. I’ve been using it, and appreciating it, for almost my entire life in the industry, but never giving back. I suppose one question that many people ask is, “Will working on open source software get me anywhere in my career?”

Getting involved

My answer is really a simple one, and may not be unique, but for me “it just doesn’t matter.” I do this because I enjoy it. It turns out, however, that working on open source software is not only extremely rewarding for me, but it is also having a big impact on my career. I do what I’m doing because I have a passion for it, and I think good things happen whenever you follow your passion.

Prove it? Well… during the first week of December 2009, I attended my first professional conference as a speaker, JSFSummit 2009 by NFJS, and presented PrettyFaces – coming nearly one year ago to the day, when I released version 1.0 (now used on production servers around the world!) I consider that having an impact. In a few months I’ll be presenting again at the Philadelphia Emerging Tech conference (April 8-9, 2010.) These are opportunities I never would have had, if not for my involvement in open source.

I can only imagine what begins to happen as ScrumShark(open source agile project management tools) starts to gain footing. PrettyFaces is one small extension for JSF; with something bigger, more powerful, the sky is the limit.

Real Rewards

For JSFSummit, I was flown to Orlando, stayed at the Loews Portofino Bay Hotel across the street from Universal MGM, and met some of not only the most interested developers, but also the most prominent figures in Java web-technology today. I met folks from Red Hat, SUN, Oracle, Scotia Bank, Children’s Hospital at Harvard, and more. Even more interestingly, I met a few people like myself: young, entrepreneurial, full time developers with a passion for creativity, and producing something for the world.

Cagatay Civici was someone I closely related to. He’s from Turkey, now living in London, only a year older than myself, and has created one of the simplest, most elegant component libraries – PrimeFaces – for JSF and JSF2. Like me, he works in his spare time to create something not just worthwhile, but something nobody else has done before. He does it well, and because he loves it.

The satin hotel greeted me with appeal of a little faux-Italian Portofino, “how did I get here?” I raced, as my black cap-toe shoe swung open the door to a double queen room with a bathroom big enough for a party. “Wow…”

I had worked – hard – for this, sometimes working as many as 8 hours a night after coming home from my full time job. I have to admit that part of me felt like pushing those double-queen beds together and jumping up and down on them. (There was no jumping, that would be highly unprofessional) After a night of food and conversation with Dan Allen – the man who really got me involved in JSF2) and his lovely wife Sarah, I was ready to go for the day-one of the conference. This was the first time we’d ever met, and I was pumped!

The hotel, a view from the bridge to Universal Studios. (I had dinner with Dan and Sarah in the white building on the far left.)

Day 1: Starting out strong

My first presentation was on the first full day of the conference: “Seam and RestEasy – You haven’t seen REST yet,” and let me tell you, before preparing this presentation, I certainly hadn’t. Seam handles REST in a way that I’d never thought Java would provide. Dynamic, automatic, CRUD. I gave the first half – on REST principles, and Dan finished up with the Seam stuff – making Seam/REST look like a two-piece, tailored suit. I was amazed, actually, that the presentation went so well, given that we had just met and put it together in a few hours the previous night. (We did work on the slides and demos in advance, though.)

Talk about a rush – my first professional conference, and I was getting to meet people I’ve been hearing about in the industry for years: Ed Burns, Jim Driscoll, David Geary, Kito Mann, Andy Schwartz, and so many more.

I was caught in a summer storm of information, wild, over before I knew it: Holistic testing of JSF applications with Stan Silvert, my first presentation with Dan Allen, Polyglot JavaServer Faces with Kito Mann, Component Framework Primer for JSF with Andy Schwartz, CDI JSR-299/Weld and the future of Seam with Dan Allen.

I’ll mention the points that “blew my mind,” and really I have to say that while all the speakers were excellent, the emerging technology that “took my cake” on day one was CDI. This is a place where Java EE is finally competing with Spring, by providing powerful contexts and dependency injection to the core Java container, even J2SE with Weld. I’m telling you, Spring is great, but CDI/Weld is serious competition. I plan on switching http://scrumshark.com/ over from Spring to CDI. Weld took the best parts of Spring and Guice and put them together with the J2EE platform… wow!

Another night of drinks, this time with more of the J2EE community out on the patio of the hotel. Time for bed again.

Day 2: The Main Event

This was my day, and I was up bright at early – still, only six hours of sleep. Let me tell you, Jay Zimmerman, owner of the No Fluff Just Stuff conference tour, truly knows how to put on a conference. All meals were provided, incredibly balanced, and equaled only by some of the best restaurants I’ve been to.

I started the day off with an egg and sausage wrap, a bowl of fresh fruit, and a cup of coffee. The first session was David Geary – Killer Web apps with JSF2.0 Ajax. “Wow,” I thought, “this guy knows how to present!” I think every other line was a joke, but I wasn’t sure because he was so clearly explaining all of the topics; I’d hire him to train at my company any day.

Andy Schwartz presented JSF2 Component Behaviors Deep Dive, and with a whopping 180 slides, my head was packed with info by the end. Behaviors open up a whole new realm of component development. If you’ve ever played a role-playing game, behaviors are like enhancements that you can add on to any piece of armor or weapon, buffs, blessings, sockets, take your pick: plug-able, reusable behavior. I plan on taking advantage of them myself. Need a reusable javascript confirmation box? Make a behavior, use it on any component.

PrettyFaces makes an appearance

My presentation was the last of the day (read the slides,) and let me tell you, I was prepared. For the last two weeks I had rehearsed (or read through my slides) almost every night, and with the Seam & RestEasy presentation under my belt, any nervousness I thought I might have had was long gone. It was ON NOW.

With good questions from Conference Attendees and JSF Expert Group members alike, discussion was not lacking at any point. People were interested, moreso than I had expected, and I was impressed that several attendees had already been using PrettyFaces in their applications!

I felt truly rewarded to hear how PrettyFaces had helped solve business problems, and how much people loved using it. I heard, “It’s perfectly simple,” “It does what I expect,” and other great feedback.

Day 3: The Big Goodbye

The last day held only three sessions, and I chose “Rapid RIA Development with PrimeFaces,” presented by Cagatay Civici. This was truly a treat – as I mentioed before, Cagatay has started something amazing. Simple components with poweful functionality. A schedule component (that looks GOOD), an entire mock Mac OSX, and over 70 components: a shell console, charts, sliders, pickers, pluggable Ajax Drag & Drop – all so easy that I felt like I could go write an app in minutes. This was my “wow” of the day; I think everyone was impressed.

Overall, I don’t think I’ve had a more exciting week in my career. This conference was almost a total surprise to me. I pushed to get myself in, and I had help, but let me tell you, “I’m glad I did it.” I’ve been struggling with the idea of, “Can I really do what I want, professionally,” and, “How do I get there?” And for me, the answers are simple: “Just do it.” Do what you love and good things will happen; share your ideas; don’t give up; make sure you take time to be human; go outside, meet people, make friends. We don’t have long to make a difference in the world (of ideas, love, music, charity, technology, …) so it’s best not to stop for one single moment.

If there’s one sentiment I can leave you, reading this far, it would be – Chase your passion.

The Future Holds…

My plans for the future involve taking Java EE, and turning it into a platform that is simple and intuitive enough to compete with PHP and Ruby for startup businesses. There’s so much power in Java EE, and I want people to know about it. Among my initiatives, since I’m already involved in JSF, was to give the new Java standard web-framework a home on the internet, a place where people can go for any information about JSF2: www.javaserverfaces.org, and the expert group members have really stepped up behind this site to make it successful.

Java EE 6 is a revolutionary release of the J2EE platform, and with Bean Validations, JavaServer Faces 2, Contexts and Dependency Injection, and JAX-RS (REST web services,) it’s never been so powerful. It’s time to take another look. We are already using everything but CDI in ScrumShark, but that will be changing soon.

A winter tale of Java Server Faces

Lincoln — Mon, 14 Dec 2009 15:27:53 +0000

As a member of the JSF 2 expert group, I’ve stated that my primary goal is to make JSF, and J2EE, more accessible to the community at large, to reach out and make sure that people’s voices are heard, and that what we are doing makes sense. I’ve only been part of the group for a little under a year, but I’ve met some pretty cool people, and you’d be surprised at how interested they all are to hear your story.

Here’s an email from David Geary (a long-time EG member) to the Expert Group, that I think paints a very nice picture of people’s reaction to JSF and JSF2, author of Core Java Server Faces (Core JSF):

I just got done with two days of training in Quebec City (you can follow my exploits, if you’re interested, at @davidgeary). The first day was advanced JSF 1.2, and I watched students’ eyes glaze over as I covered the complexities of custom components, renderers, converters, and validators. Java code, XML configuration, encoding, decoding, etc. — you know the drill. One of the developers had used Rails, and he looked downright depressed. But I knew day 2 would be different. Oh yeah.
Because day 2 was all JSF 2, and it was an entirely different story. I started with an overview of the new features in JSF 2, and then dove deeply into Facelets, templates, composite components, and Ajax. Students were blown away. Blown. Away.
What was a fairly sullen group on day one turned into a rambunctious group of excited developers on day two. Could they use JSF with WebLogic 10? they wanted to know. What about RichFaces, when will that support JSF 2?, they asked. Until we upgrade to JSF 2, can we do this templating stuff with the open source version of Facelets?. The Rails guy was all smiles. This is pretty cool, eh? I said (eh, if you don’t know, is Canadian for hunh). Oh yeah, they said. Oh yeah.
As I was covering JSF 2, I could feel the excitement building in the room. Lots of smiles, lots of laughter, and excited chatting and whispers in the incredibly beautiful language that is Quebec French, between students. It was really phenomenal.
Early in the morning, the blizzard started. I’m teaching class, and, out the window, snow is coming down like hell, in all different directions because of the fierce winds that accompanied a major snowstorm that dumped nearly a foot of snow on the ground during class. I started out with 11 students, and by the time I finished class at the end of the day, I had … 10 students! I’m telling you, those guys were mesmerized by JSF 2. Even though the weather gave them good reason to leave class early, only one guy, who had kids that he had to pick up because les ecoles etait fermer, left class early.
I got done with the material, and told them that they were free to go, that they probably should go because of the storm, but that I’d be happy to answer questions, and even with the intense blizzard raging outside, they all stuck around for another 1/2 hour, brainstorming with me about how they could upgrade from 1.2 to 2.0, given their current situation.
For me, this training, unlike any other I’ve ever done, was almost a religious experience. For us, it’s validation that all the hard work we’ve put into JSF 2 is paying off.
A bientot,
David

Now, I – for one – find this exciting! This is another great sign that we’ve done things right with JSF2. The best part is, we are only going to keep improving. Want to get involved? Tweet your suggestion using #jsf2next – or put issues directly into the JSF2 Issue Tracker (all you need to do is register for, or use your existing java.net account.)

What does the future hold? That’s up to you to decide… For more information on JSF 2 features, a getting started guide, how to give feedback, get involved, and why JSF 2 is a leading web-framework, visit www.javaserverfaces.org.

You can read this email on David’s blog, here: http://davidgearyblog.wordpress.com/