Session Schedule

By Ed Burns

We'll share interviews and insights on how JSF is used in production from several fun customers.

This presentation is a survey of real world JSF usage around the world. From social network hardware in Lausanne, Switzerland, to GPS hardware in Kansas City, U.S.A., to socially responsible investing in London, to purchasing aboriginal art in Alice Springs Australia, JSF is in action everywhere. We'll share interviews and insights on how JSF is used in production from several fun customers.

By Ed Burns

This presentation will explain how to use the composite component feature of JSF 2.0. This feature enables turning any chunk of page markup into a true reusable JSF UI component, complete with all the features one expects of a reusable Object Oriented component.

Specifically the presentation will focus on events, listeners, templating, and scripting, all from a perspective of composite components.

By Dan Allen and Andy Schwartz

This presentation will provide an in-depth introduction to many of the new JSF 2.0 features and will ask of each: Is the currently specified solution sufficient? We'll also consider whether other concerns (paper cuts) have been overlooked?

The JSF 2.0 specification (JSR-314) addresses a substantial number of long standing pain points that JSF users have just come to accept as a hard knock life (or death by 1000 paper cuts). At last, JSF is a true contender amongst web frameworks. Now that the specification final, it's time to take a step back, evaluate the results and look ahead to JSF 2.1. Here's a partial list of the features we'll be covering: State saving: We'll introduce the new partial state saving solution in JSF 2.0 and consider whether additional utilities are needed for stricly stateless use cases. GET support: At long last, JSF now supports GET request processing in the form of bookmarkable URLs and request param

By Dan Allen and Lincoln Baxter III

JSR-311 (JAX-RS) is one of the simplest, most elegant of all the Java EE specifications and is showing early signs of becoming an overwhelming success. It lets you to create RESTful web services from existing Java EE components by sprinkling a handful of annotations over it. But the downside is that the resource must be a Java EE component. Seam's RESTEasy module allows you to use JAX-RS annotations on your existing Seam components, giving your web services access to the Seam container and, dually, an alternate interface to your Seam application.

In this talk, you learn how you can use your Seam components as REST resources using the Seam RESTEasy module. The most obvious benefit is that you can create RESTful web services using a Seam component and get access to full Seam injection, security, persistence management, and so on. You almost forget that Seam eliminates the configuration required to add JAX-RS to your application. You'll be enthralled by the module's innovative approach to doing CRUD over REST that mimics Seam's CRUD framework for JSF-based UIs. Finally, you learn about some nice extras that Seam provides such as exception handling and integration with Seam security.

By Dan Allen

Learn how Seam's security can protect your application throughout the development life cycle, from simple authentication to fine-grained, rule-based security restrictions.

Security is the cornerstone of your application's integrity and, therefore, it should be a key component of any enterprise framework. And you'd rather the complexity be confined to the security rules, not contributed by the security framework itself. Seam's security module is a central component of the Seam framework and offers a significantly simpler alternative to the monolithic and complex Java Authentication and Authorization Service (JAAS) in Java EE. In this talk, you learn how Seam Security allows you to evolve the security model of your application over time, keeping inline with the development cycle. The talk starts you off with a very simple configuration that applies a security

By Dan Allen

This talk introduces JSR-299: Contexts and Dependency Injection for the Java EE platform (CDI), the new Java standard for dependency injection and contextual lifecycle management. The talk covers the core programming model, explains its relationship to EJB 3.1 and JSF 2.0, and clarifies how it unifies and enhances the Java EE platform as a whole (extending to JPA, JAX-RS and JMS). You are then introduced to Weld, the JSR-299 reference implementation, and its servlet container extension. Finally, we look ahead at how a modularized Seam 3 ties into this new foundation as a set of portable CDI extensions, previewing several examples.

JSR-299: Contexts and Dependency Injection for the Java EE platform (CDI) is an elegant set of new services for Java that draws upon ideas from popular frameworks such as Seam and Guice and hooks into all the major specifications in the platform, including JavaServer Faces (JSF) 2.0, Enterprise Java Beans (EJB) 3.1, the Java Persistence API (JPA) 2.0 and JAX-RS 1.1. While many of the features provided by CDI--dependency injection, contextual lifecycle, configuration, interception, event notification--are familiar, the innovative use of meta-annotations is uniquely expressive and typesafe. This talk emphasizes the value in this approach. Seam is a powerful open source development platform fo

By Jay Balunas

In this session we'll explore some of the corners of the RichFaces toolbox in detail and give you a taste of some advanced functionality. This will include a demo of RichFaces drag-n-drop, ajax request queues, layout components and more. I'll also be covering some recent changes to the project, and our plans for RichFaces 4; for example, how RichFaces 4 with full JSF 2.0 integration will change various components such as a4j:support, the Component Development Kit (CDK), etc….

RichFaces is a large and diverse component library that has influenced the JSF 2.0 standard. With over a 100 AJAX enabled components there is always something new to try. This session aims to expose attendees to RichFaces functionality they may not have seen before, because when it comes to component libraries many people tend to use the same small set of components, and rarely deviate. That's like eating the same food every night - there's a lot more in RichFaces to experience!

By Jay Balunas

This session discloses best practices, tips and techniques and including inside information to save you in a pinch and maximize your use of Seam, RichFaces, JSF and Facelets.

Dan and Jay have amassed a catalog of hidden gems and lesser known facts while developing in the RIA ecosystem. This session discloses some of those best practices, tips and techniques and gives you inside information to save you in a pinch and maximize your use of Seam, RichFaces, JSF and Facelets. If you are a developer working with any or all of these technologies today, this session is a must see to help you find the path to success while avoiding the slippery steps.

By Lincoln Baxter III

J2EE is already the perfect solution for complex business/enterprise systems, and JSF2.x is the perfect chance to reach out to the consumer and small business market. JSF is easier to use than it's ever been before, but small businesses have different needs than larger companies and corporations. PrettyFaces, however, is not just for small businesses; this session will present how it makes JSF accessible for anyone developing client-facing applications, addressing SEO optimization, and creating clean, consistent, intuitive client interactions on the web.

How PrettyFaces works: The talk introduces you to URL rewriting, storing contextual information - safely - and managing page configuration data with address and query parameters. PrettyFaces' centralized approach uses URLs to retain the state of pages, meaning less information must be stored in session and application scoped beans. Rethinking navigation: Navigation from the eye of the client. JSF supports page flows well, but managing simple transitions from one page to another can be complex. Examples of PrettyFaces integrated navigation, hyper-linking via Bijection and Components will show how developers gain increased control over all aspects of navigation out of the box, and how this i

By Andy Bosch

The session will demonstrate the features of BIRT and Jasper and will give recommendations of how to integrate them with JSF.

When creating business web applications, reporting is often an important requirement. Customers like to see colorful charts, tables with drill down functions and of course would like to have the possibility to export the results as a MS-Excel file. With Eclipse BIRT and JasperReports the Open Source community offers two solutions to this issue. But how can you integrate these two into JSF? The session will demonstrate the features of BIRT and Jasper and will give recommendations of how to integrate them with JSF.

By Cagatay Civici

This session covers everything about PrimeFaces family and it's subprojects featuring UI Components, Ajax Push, mobile JSF with TouchFaces, Optimus and FacesTrace.

PrimeFaces is an open source library for JSF with 60+ rich set of UI components and a lightweight ajax framework making complex RIA applications a no-brainer to implement. Additional TouchFaces subproject provides a mobile UI kit for developing IPhone applications with JSF and Java. This talk covers everything about PrimeFaces family and it's subprojects featuring UI Components, Ajax Push, Mobile Application Development with JSF, lightweight JSF-Guice-JPA stack, tracing and more.

By Keith Donald

Spring's approach to integrating JavaServerFaces technology is novel and innovative; an approach that lets you maximize your investment in Spring while still adhere to standard JSF idioms. In this session, Keith will go "behind the scenes" and explore the framework architecture underpinning Spring's JSF integration. Attendees will gain valuable framework design and architectural insight.

A deep-dive design session into how Spring and JSF integrate, and how the integration has evolved over the years.

By Keith Donald

In this session, Keith will demonstrate how developers typically use JSF and Spring together in practice, as well as explore the latest integration enhancements available in Spring 3. Attendees will leave with an understanding of how to use JSF and Spring together to create rich web applications.

Attendees will learn: * How to integrate JSF 2 with Spring 3 * How to use popular JSF libraries such as Trinidad and Rich Faces in a Spring environment * Patterns and practices for getting the most out of Spring in a JSF application * The extended capabilities Spring provides in the areas of Ajax, persistence, security, friendly URLs, validation, navigation, state management, and exception handling; capabilities that enhance the JSF application development experience

By Michael Freedman

The Portlet Bridge (JSR 301 or JSR 329) provides a Faces compatible runtime environment in a Java portlet environment enabling a JSF application to simultaneously be published as a web application and a portlet. This talk introduces you to the Portlet Bridge and shows you how to use it in your applications.

Demonstrations are provided to illustrate concepts. Topics covered include: * The difference between JSR 301 and JSR 329. * Extending a Faces application so it also runs as a portlet. * An overview of the bridge's configuration flexibility to adapt to differing Faces and application environments.

By Michael Freedman

In the recent past both Java Portlets and JSF have published their 2.0 versions. This talk introduces you to how the major new features in each of these 2.0s are managed by the bridge.

The Portlet Bridge provides a Faces compatible runtime environment in a Java portlet environment enabling a JSF application to simultaneously be published as a web application and a portlet. As a technology that sits between two others (the Java Portlet API and Faces), its capabilities expand as the controlling technologies are revised. Demonstrations are provided to illustrate concepts. Topics covered include: * Portlet 2.0 shared render parameters * Portlet 2.0 eventing * Portlet 2.0 resource serving * JSF 2.0 Ajax support

By David Geary

JSF 2 draws from open-source Ajax frameworks to provide built-in Ajax that's simple and easy to use. Come to this session to see how to take advantage of that Ajax to implement killer web apps with JSF 2.0.

When JSF 1 came out in March 2004, the term Ajax had not yet been coined, so JSF 1 did not come with Ajax support. Over the years, several Ajax frameworks were developed for JSF, most notably ICEFaces and Ajax4jsf, both of which were hugely popular. For JSF 2, the authors of the most popular JSF Ajax frameworks joined the JSF 2 Expert Group, and helped to define JSF 2's built-in Ajax capabilities. JSF 2 Ajax is a simple, but powerful kernel of Ajax functionality that you can use to build rich client user interfaces.

By David Geary

In this talk, you will learn about JSF 2's support for templating, and how that feature is used to implement the most powerful feature in JSF 2: composite components. A live-coding fest, this session will teach you how to implement reusable components, and whet your appetite for implementing killer web apps with JSF 2.0.

Components are a powerful concept. You can share and reuse components, making it easier to develop application-specific functionality. Components, however, were rendered essentially inconsequential with JSF 1 because they were so difficult to implement. JSF 2 finally brings the power of components to the common man by letting him easily implement components, with no Java code, and no configuration.

By Ted Goddard

Ajax is now part of the JSF 2.0 standard, but the easiest way to add Ajax to your application still requires ICEfaces or another JSF component suite. Learn how to use the Ajax features of JSF 2.0, then see how this is automatically provided by ICEfaces, and take it a step further with collaboration features via Ajax Push.

This talk covers three main topics in detail: * Ajax features in JSF 2.0, for the application developer and framework developer, including and the Ajax extension points in the API such as PartialViewContext and PartialResponseWriter * Ajax development with ICEfaces components * Ajax Push demos and development with ICEfaces

By Ted Goddard

This session provides an overview of the mobile web and how to develop for it with the ICEfaces Ajax framework. Learn a variety of JSF application techniques that allow both mobile and desktop users to be targeted simultaneously.

It's time to bring our Ajax applications to mobile devices, but there are a number of challenges, including reduced bandwidth, increased latency, reduced screen size, and browser variations. Attendees will take away an understanding of the mobile web and its convergence with the desktop web, and will learn how to accommodate mobile users in their current JSF applications.

By Neil Griffin

This talk will demonstrate how easy it is to develop social networking portlets with ICEfaces and Liferay. Attendees will learn the fundamental techniques through code walkthroughs of ICE Friends and ICE Chat portlets, leveraging Facelets composite components and real-time status updates via Ajax Push.

Social networking is a natural addition to the portal, already a meeting place for applications. Diverse systems and users can be brought together for web-based communication and collaboration. When introduced to Ajax Push, portlets provide real-time communication features such as presence, chat, and new forms of application-specific interaction. Attendees will also learn about PortletFaces, a new open source project that enables a more JSF-centric approach to building portlets that use vendor-specific features of Liferay Portal.

By Ian Hlavats

This talk focuses on combining the creative power of Adobe Dreamweaver with the productivity of NetBeans to develop next-generation JSF applications. Participants will learn how to use Dreamweaver code hints and the syntax auto-complete feature to develop Ajax-enabled JSF pages using the RichFaces Tools for Dreamweaver and Seam Tools for Dreamweaver plugins.

Techniques for separating application development concerns, such as user interface design and backing bean programming, will be demonstrated. The presentation will be mostly hands-on with a live demonstration of how to build a simple JSF application using standard and custom components from start to finish using Adobe Dreamweaver, NetBeans, the SeamGen utility, and a MySQL database.

By Ian Hlavats

This exciting presentation focuses on the interoperability of the Adobe Photoshop, Dreamweaver, and the popular Eclipse platform to create next-generation JSF applications. Participants will see how to combine the creative power of Adobe software with the productivity of Eclipse to rapidly develop new JSF applications from start to finish.

Key highlights of the presentation include creating and deploying new JSF projects in Eclipse with the Web Tools Platform, generating advanced CSS-based layouts like professional web designers do, creating Facelets templates in Dreamweaver, dragging and dropping JSF components to build pages in Dreamweaver, data binding and event handling with JSF forms, and debugging a running JSF application in Eclipse.

By Max Katz

This session will demonstrate how to build Ajax applications with new RichFaces 4.0 and JSF 2.

RichFaces is a rich JSF framework with over 100 Ajax components, skins, themes and rich component development kit. Although JSF 2.0 now offers basic Ajax functionality, a rich component library is still needed to build JSF Ajax applications. This session will demonstrate the new RichFaces 4.0 (JSF 2 based) as well as demonstrate what advanced features, customization, flexibility and richness it adds on top of JSF 2.0.

By Micha Kiener

The edoras Framework provides a suite of JARs that compliment JSF, ICEfaces, and the Expression Language (EL). It also includes loosely coupled integration with Spring, JPA, Liferay, and includes a versatile workflow engine with a graphical workflow designer for Eclipse. With PortletFaces, edoras provides a lot of glue-code and utilities to really speed up your Liferay development with JSF.

This session will introduce you to the edoras Framework and how it can simplify your JSF applications, whether they are JSF webapps or JSF portlets. Demonstrations of real world applications and source code walkthroughs will wet your appetite for this exciting new compliment to JSF, ICEfaces, and the EL.

By Micha Kiener

Attendees will take away the information they need to add conversation management and extended scopes to their JSF web application provided by Spring 3.1.

Ever struggled with too few scopes in JSF? Session is too long, request too short, view (JSF 2.0) not really addressing your needs? This talk will give you an inside view into the new conversation management feature and extended scopes of Spring 3.1 in combination with JSF. Spring 3.1 features a new window scopes to keep browser windows and tabs apart from each other, and a complete conversation management to scope your beans along the boundaries of a use case defined by business logic rather than a technical approach. The session provides a detailed introduction to extended scoping and conversation management plus real world examples and demos.

By Kito Mann

It's no secret that languages other than Java are gaining popularity on the Java Virtual Machine. We often hear about how new languages like Groovy, Ruby, or Scala can speed up development and reduce boilerplate code. What isn't always clear is how to apply these languages to JavaServer Faces applications.

This session looks at different techniques for using other languages with JSF. We'll look at built-in Groovy support in Mojarra, using Groovy as a DSL for JSF with Gracelets, writing JSF applications with Scala, and discuss Spring and Seam support for scripting.

By Kito Mann

Now that JavaServer Faces (JSF) 2.0 is out, what do you do with that recently completed JSF 1.x application? Like most Java standards, JSF 2.0 strives for backwards compatibility. However, if you want to use new features like simpler UI components, new events, Groovy components, or the built-in Facelets support, you will have to perform some upgrade steps.

In this session, we'll walk through the process of upgrading a JSF 1.x application to JSF 2.0, pointing out areas that may benefit from new features.

By Martin Marinschek

How to select a conversation scope framework in the age of war of the dependency injection frameworks.

Seam has one, Orchestra has one, Webflow has one, some JSRs have one, Spring 3.1 plans to have one: but who has the best conversation scope for your everyday needs? How does one select a conversation scope framework in the age of war of the dependency injection frameworks? Some clear winners seem to emerge if you follow the new standardization efforts for dependency injection, and JSR-330 might be the base for all your dependency injection and JSR-299 on top of JSR-330 the base for all your conversation scope needs in the future.

By Martin Marinschek

This session explains how you can build accessible JSF applications with or without JavaScript.

We will discuss why JSF should work completely without JavaScript as a fallback, how this can be achieved, and which component suites have already implemented this feature. Furthermore, we will look into how you can still build accessible web-applications - even if JavaScript is used.

By Martin Marinschek

We will look into the last year's development of the MyFaces component libraries and how their community reacted to the JSF 2.0 feature enhancements.

It has been half a year since JSF 2.0 has been released - let us see how the MyFaces community has responded to this, what parts of the new standard have been implemented, and what parts remain to be done.

By Andy Schwartz

For each area we will compare and contrast approaches taken by the three frameworks with an eye on understanding the strengths and weaknesses of each solution. We will also consider whether there are opportunities to improve JSF itself based on lessons learned from our comparative analysis. Attendees of this presentation should expect both to gain insight into how new features provided in JSF 2.0 can simplify development, and should come away with a better understanding of how other frameworks have tackled similar problems.

JSF 2.0 includes many new features that simplify both component development as well as application development. This presentation looks at the new revision of JSF and compares it to two other popular component-centric web frameworks: Wicket and Tapestry. We will start by answering a simple question: What constitutes a "component" in each framework? We will then examine other framework features including: Page construction Data binding Input processing and validation Event handling Navigation Ajax support

By Andy Schwartz

The JSF component "behavior" model is a new feature introduced in JSF 2.0 in order to facilitate Ajax support. Component behaviors allow commonly used client-side functionality to be bundled into reusable objects that can be associated with arbitrary components. While the JSF specification currently defines only a single component behavior, the component behavior model is designed for extensibility, allowing anyone to create and share their own component behavior implementations.

This presentation provides an introduction to the component behavior model, including an overview of the new APIs as well as background on the requirements that drove the API design. We will explore how to create custom component behaviors and perform an in-depth walk through of a sample Google Suggest-inspired component behavior implementation. By the end of this presentation, attendees should be ready to take advantage of this new API and create their own component behaviors.

By Stan Silvert

This session will present everything you need to get started building a test suite that validates your JSF application from end to end.

In the past, testing your JSF application was considered difficult, if not impossible. However, with the new tools included in JSFUnit, you can create outstanding test coverage that rivals or beats the tests you would write for other frameworks. You can even do test-driven development and continuous integration, which was virtually unheard of in the JSF world before.

By Stan Silvert

JSFSpy instruments your JSF application to record everything that happened in multiple requests over multiple sessions. It's similar to being able to see the Facelets error page for all previous requests. The difference is that JSFSpy provides a lot more information, including state transitions of scoped data, performance stats, and a complete dump of the HttpServletRequest.

We'll also talk about how to extend JSFSpy using a new idea called WARlets.

BRING YOUR LAPTOP FOR AN INTERACTIVE DEMO!

JSFSpy is written for JSF 2, so it includes things like the ability to track data in custom scopes. We'll talk about how JSFSpy uses new JSF features and also how it takes advantage of Servlet 3.0 features to make it into a simple, WAR add-on that only requires a jar inside WEB-INF/lib. That means that JSFSpy requires no modification to web.xml or faces-config.xml. We'll also talk about how to extend JSFSpy using a new idea called WARlets. BRING YOUR LAPTOP FOR AN INTERACTIVE DEMO!