Session Schedule

By Christian Schalk
In this session, specific examples of how to integrate JSF applications with these server-side Google technologies will be first described in detail and then demonstrated.

With Google's ever-growing list of server-side technologies, JavaServer Faces like other server-side Java technologies can readily take advantage of these new technologies. JSF developers can now enhance their applications with data from popular Google technologies such as: OpenSocial's REST Services, Google Data APIs which provides server-side access to technologies including: Blogger, Google Calendar, Google Spreadsheets and more. Attendees will receive a firm understanding of all the server-side Google Java and REST technologies that can be integrated with JSF and server-side Java in general.

By Cagatay Civici
Apache MyFaces is a popular open source project from ASF that hosts several JavaServer Faces related subprojects.

These include the core JSF implementation, component suites (Tomahawk, Trinidad, Tobago),Orchestra project for conversations with persistence integration and the portlet-bridge project. This talk covers the MyFaces world and explains how MyFaces solutions can enhance JSF based applications.

By Cagatay Civici
This session introduces several solutions to these security requirements and demonstrates Spring Security(Acegi) integration with JSF.

JSF applications have different levels of security requirements like URL protection, component level authorization, viewstate security and more.

By Dan Allen
This session presents the approach to conversations and pageflows taken by each of JBoss Seam, Spring Web Flow, and Apache Orchestra frameworks. It addresses the pros and cons of each option with the primary focus being on how well they fit with JSF.


Not to long ago, the web came out of its shell and become social. I'm not talking about social networking sites, but rather communication between individual page views. JBoss Seam, Spring Web Flow, and Apache Orchestra all introduce a conversation context whose purpose is to maintain state that pertains to a use case across a series of pages.

Conversations help ween developers off of the HTTP session, being a far more attractive option because their life cycles can be managed independently from one another. They also last on the order of minutes rather than hours, reducing load on the memory footprint on the server. In addition to a long-running context, conversations can be combined with pageflows offered by each framework, which constrain a user's navigation path to predefined sequence. As such, pageflows can help reduce the complexity of navigation in an application.

By Dan Allen
This talk introduces the Ajax4jsf CDK, demonstrating how to setup a new JSF component project, how to author the component using the CDK descriptors, and how to bundle the component for use in another application. The resource framework in Ajax4jsf is also covered, which simplifies the task of serving JavaScript, CSS, and images necessary to support rich components.


For The pains of developing JSF components are fairly well documented. The extensible design of JSF components results in a plethora of required configuration files and classes which are reminiscent of EJB 2 artifacts (and no more fun to development and maintain). What's worse is that the rendered markup must be written in Java code, a step backwards towards Java servlets. Fortunately, the Ajax4jsf Component Development Kit (CDK) automates the task of creating the UI component and renderer classes from a single, descriptive XML configuration file and an accompanying JSP-style template. The Ajax4jsf CDK, a module of the RichFaces project, is a Maven 2-based development environment that takes away the monotonous coding and complexities of developing JSF components for both JSP and Facelets.

By Dan Allen
By attending this talk, developers can suppress their anxiety about the coexistence of the two frameworks, open their eyes to the potential that each boasts, and learn how to combine them to create a more powerful tool for their development toolbox.



The Spring Framework and JBoss Seam are both lightweight inversion of control (IoC) and aspect-oriented (AOP) containers that champion the POJO programming model, though with slight variations. Each framework offers a dependency injection (DI) mechanism, ORM integration, declarative transactions, web service clients and endpoints, asynchronous messaging support, and other parallel integrations. The apparent overlap in the goals and features of these two frameworks has bred staunch competition amongst them, causing sparks to fly at times. This situation leaves the developer feeling conflicted as to which framework to employ and master. The choice, however, is not an exclusive one. In the dog eat dog world of today's technology market, the opportunity to create a federation between application frameworks is often overlooked. Spring and Seam share this symbiosis. POJO programming, which is endorsed by both frameworks, yields reusable objects that are not tied to infrastructure services and can thus be used in standalone environments. For Spring classes, that alternate environment can be a Seam application. This session will demonstrate how it is possible to take advantage of the vast, capable, and mature Spring APIs from within a Seam application, how Seam can leverage existing Spring components, and how Seam can contribute its capabilities back to the Spring container. Finally, this session will demonstrate how Spring and Seam can share resources, namely ORM persistence contexts and global transactions. This session hopes to raise awareness of the benefits of this union.

By Daniel Hinojosa
Seam (which includes JSF) is component based and it does require some degree of mental retraining from the common request/response way of doing web applications. Because of this, developers do fall into misconceptions and anti-patterns regarding component based web frameworks.

This presentation will cover these common traps and pitfalls that Seam developers will encounter. We will cover LazyInitializationExceptions and why they happen, understanding conversations better, understanding bijection, give a thorough understanding with AJAX requests in the Seam environment, and give you well-rounded advice on building your application with Seam

By Daniel Hinojosa
The presentation will cover Seam-included testing utilities as well as other open source utilities like EasyMock, Hudson, and Selenium.


A presentation on how to effectively unit test, integration test, and acceptance test Seam applications so that you can deliver a high-quality applications to your customers.

By Daniel Hinojosa
Seam (which includes JSF) is component based and it does require some degree of mental retraining from the common request/response way of doing web applications. Because of this, developers do fall into misconceptions and anti-patterns regarding component based web frameworks.

This presentation will cover these common traps and pitfalls that Seam developers will encounter. We will cover LazyInitializationExceptions and why they happen, understanding conversations better, understanding bijection, give a thorough understanding with AJAX requests in the Seam environment, and give you well-rounded advice on building your application with Seam

By David Chandler
In this section, we explore how JSF protects against these attacks and move on to explore JSF extensions you can deploy to provide complete protection against the OWASP Top Ten, including forced browsing, information leakage in select boxes, and unauthorized method execution.

The JavaServer Faces (JSF) API is an excellent foundation for building secure Web applications because of its component-oriented nature, carefulness surrounding data validation, and numerous extension points. The leading JSF implementations build on this strength by providing components which offer built-in protection against many of the OWASP Top Ten attacks including form parameter tampering and cross-site scripting. Specifically, we?ll look at centralized approaches to ensuring that every field and form is properly validated, a phase listener and view handler to prevent forced browsing and assist with detection of session hijacking, and a customer converter and component to hide sensitive information such as IDs in menu options.

By David Geary
Have you ever stopped to think that you need to learn two frameworks to develop a non-trivial, database-backed, web application? Struts and iBatis; JSF and Hibernate; Tapestry and EJB3.0.

Two frameworks. And then you have to learn to use them together. Why do we have to learn two frameworks just to retrieve "Hello World" from a database and show it in a view. Isn't that crazy?

Now you can use one framework, and use one component model. One. Isn't that nice?

By David Geary
Facelets is a combination of Tiles and Tapestry, and it's the hottest JSF-related open source project on the planet.

It's popularity is well deserved, and in fact, much of what is in Facelets today will make its way into the JSF 2.0 spec due out in 2008. So not only can you come to this session and see some really cool demos that you can put to use in the real world, but you'll also be learning JSF 2.0 before it's even been defined! How's that for a ROI?

By David Geary
In April 2005, annual growth rates for jobs in JavaServer Faces, Struts, and Ruby on Rails were all at about 0%. Today, Struts' growth rate still hovers around 0%, but JSF and Rails have taken off. At the end of 2007, both JSF and Rails were growing at a rate of between 400-500% annually (according to indeed.com).

JSF has passed the adoption tipping point, and is now the Java-based framework of choice, as is evidenced by its ecosystem. From vendors such as MyEclipse and RedHat to open source projects such as Seam, Facelets, and Ajax4JSF, JSF is where the action is.

Come see why JSF is so popular. In this code- and demo-intensive session, I'll show you the fundamentals of JSF.

This session is taught by a member of the JSF Expert Group for JSF 1.0 and 2.0., and co-author of the best-selling book on JSF: Core JavaServer Faces. David will take you through a whirlwind introduction to JSF including what JSF is, how it was developed, and how you can best take advantage of the technology. Here is a list of topics:

Components, managed beans, value expressions, and static navigation
i18n, CSS, and actions
The Faces Context and Faces messages
The JSF Event Model
Using JavaScript with JSF

This introduction to JSF also contains 5 live-code demos, where David will develop a simple, but robust application during the course of the session.

Prerequisite: Some knowledge of Java-based web applications, such as Struts, is a plus, but is not required. If you have a significant experience with JSF, you probably already know most of what's covered in this session.

By David Geary
Ajax4jsf makes it very easy to add Ajax to your JSF applications. Come to this presentation to see how.

The JSF spec has changed little since JSF debuted in 2004. However, the open source community is a frentic cauldron of activity that has produced lots of cool innovations, many of them related to Ajax. In this talk, we'll look at one of the most popular open source Ajax frameworks for JSF, Ajax4jsf.

Ajax4jsf gives you a very capable set of low-level Ajax tags (JSP or Facelets), along with their corresponding APIs, that let you easily incorporate Ajax features, most of the time by just using a custom tag or two. Ajax4jsf is an ideal solution if you want to add Ajax functionality to an existing JSF application.

In early 2008, the JSF Expert Group has begun to focus it's attention on incorporating concepts from best-of-breed JSF Ajax frameworks, such as Ajax4jsf and ICEfaces. What you learn in this session will give you both a preview, and a leg up, on JSF 2.0.

By Ed Burns
In this 90 minute session, Ed Burns will clear up the fog that sometimes
surrounds people's understanding of this Web Application Development
Framework. Ed is well suited to the task, having helped shape the
design of JSF from its inception up to the present day. Upon leaving
this session, the participant will know what JSF is good for, why it is
good for these things, and how to be productive using it.

In this 90 minute session, Ed Burns will clear up the fog that sometimes
surrounds people's understanding of this Web Application Development
Framework. Ed is well suited to the task, having helped shape the
design of JSF from its inception up to the present day. Upon leaving
this session, the participant will know what JSF is good for, why it is
good for these things, and how to be productive using it.

Everyone already knows what a web-application is and when it's
appropriate to use them. Therefore, the session skips the small stuff
and starts out by building a strong foundation by exploring the four
pillars of JSF: the View, Model interaction, the Lifecycle, and the
Navigation Model.

With these concepts firmly understood, we cover some JSF design
principals and patterns used all over JSF. Patterns discussed include
decorator, singleton, strategy, template method, and observer. For each
pattern, its use in JSF will be covered in detail, with emphasis on how
the pattern is used to enable developer customizations.

The participant then learns about Type Conversion, Validation, Events,
and the flexible rendering model.

A running example will be constructed throughout the presentation.

By Ed Burns
This session will prep the attendee for other JSF 2.0 related sessions, giving the attendee exclusive insight into what's coming in JSF 2.0.

This session will prep the attendee for other JSF 2.0 related sessions, giving the attendee exclusive insight into what's coming in JSF 2.0. We will discuss what is happening in the JSF 2.0
standardization process - what will be the new features, where we are at, what we will still do until the new standard is finished.

By Ed Burns
A broad look at the history of network-aware application user interfaces, analyzes the current state of the art for building such UIs, and explores some attributes of the successful UIs of the future.


A broad look at the history of network-aware application user interfaces, analyzes the current state of the art for building such UIs, and explores some attributes of the successful UIs of the future.

By Emmanuel Bernard
In this session, Emmanuel will introduce the Web Beans programming model step by step and describe how Web Beans integrates with existing Java EE technologies, such as EJB 3.0, JSF, and Servlets, and how it dramatically simplifies the EE programming model.

Web Beans is an elegant new component model for Java that draws upon ideas from JBoss Seam and Google Guice. While many of the features provided by Web Beans (dependency injection, contextual lifecycle, configuration, interception, event notification) are familiar, the innovative use of meta-annotations is uniquely expressive and typesafe.

By Ian Hlavats
The creative side of JSF user interface design is underrepresented in many books, technical articles and discussions. This session aims to give some visibility to the design tools and techniques used by creative professionals, and will examine the sometimes surprising gap between what Web designers and Java developers consider intuitive in a JSF context.

Learn how to use Adobe Dreamweaver to take creative control of your JSF presentation layer and create web user interfaces with Facelets, Seam, and Tomahawk. We will explore methods used by professional Web designers to enhance the usability and visual appeal of JSF pages. We will also discuss examples of real world issues encountered by JSF design and development teams, and explore design patterns and strategies that have proven to be effective at bridging the gap between these two disciplines.

By James Cook
Join JSF Expert Group member Jim Cook on an exploration of a sophisticated JSF application which uses spreadsheets and graphs - in a browser - to highlight JSFs abilities, with an eye toward JSF coding patterns, best practices, and JSF's overall ease of development for the enterprise programmer.


JSF is a powerful JEE framework that is bundled with JEE 5. It adds the missing layer to Enterprise applications: a sophisticated View technology which makes creating highly interactive web applications simple. For Model 1 and Struts developers JSF represents an opportunity to leverage their existing code and quickly build applications that make the most of AJAX and reusable JSF components.n spite of this, there is a perception among non-JSF developers that JSF is obscure, difficult and non-performant.

By Jason Lee
Have you ever wanted to work on the industry-leading JSF 1.2 implemntation, but didn't know where to start? Or, have you ever been curious what the implementation looks like behind the scenes?

In this presentation, we'll take a look at the build environment, tools, and processes that Mojarra has in place, giving you just about everything you need to sit down and fix your favorite bug, or, perhaps, cook up the next great enhancement.

By Jason Lee
One of the improvements coming in JSF 2 is the vast simplification of component development, but JSF 2 is months away, and you want that functionality NOW, so what's an impatient developer to do?

Enter JSFTemplating and JSF Extensions. Using these two libraries, it is possible to use an approach very similar to what JSF 2 will offer, but can be done using JSF 1.2. In this presentation, we'll peek under the hood of Mojarra Scales, a component set that uses this approach, and see what it has to offer.

By Jason Lee
Just about everyone is familiar with Facelets -- and with good reason -- but did you know there's another major alternative?

JSFTemplating is a ViewHandler implementation that has been around for years -- actually predating Facelets a bit -- that offers some very compelling features, such as pluggable template formats and event handlers. It's even (mostly) Facelets-compatible, giving the user the best of both worlds. If you'd like to take a look at part of the technology that powers, for example, the Admin Console in the GlassFish application server, this presenation is for you!

By Jeremy Grelle
Traditional JSF development has gained a reputation for being overly complex and cumbersome. Spring Faces introduces a host of features that improve the development experience and performance of a JSF + Spring application. Attendees will see a real-time demonstration of how Spring Faces makes the JSF experience more productive and reduces the pain of container re-starts and verbose configuration.

This live coding session will show how to quickly prototype a Spring Faces application and utilize the features of Spring Faces that make using JSF and Spring together a more cohesive experience:

- High-level DSL for structuring control logic that utilizes EL and Groovy and is both easy to unit test and fully dynamic and refreshable in-container at runtime.

- Introduction of view and flow scopes that fit more naturally with JSF's stateful model

- Reduction in external configuration with no need for JSF managed- bean or navigation-rule definitions

- Easy-to-introduce client-side validation and Ajax

- Flow-managed persistence contexts that enable true transparent persistence.

- Simplified integration with Spring Security

- Less conceptual disconnect by enabling the Spring programming model throughout the stack ("turtles all the way down")

By Keith Donald
In this session, Keith will demonstrate how JSF developers traditionally use JSF and Spring together, then explore new opportunities for using these two technologies together that can result in significant productivity gains. Attendees will learn the viable approaches to using JSF and Spring together to create rich web applications.

Attendees will also gain insight into:
- How Spring integrates with popular JSF libraries
- Patterns and practices for getting the most out of Spring in a JSF application
- How Spring uses the JSF lifecycle to provide UI navigation handling and state management
- The capabilities Spring provides in the areas of Ajax, persistence, security, friendly URLs, and exception handling

By Keith Donald
Spring Faces is an innovative project that allows native JSF components to work inside a familiar Spring MVC and Web Flow environment. This combines the best of action-oriented and component-oriented approaches, and can greatly enhance the development experience and reduce the learning curve of building and running a JSF web application. In this session, attendees will take a deep dive into how Spring MVC and Web Flow enable this model and add power and simplicity in the areas of navigation control, state management, and application modularity.


In this session you will learn:
- How to implement reusable application modules as self-contained bundles that can be refreshed without container restart
- How to solve the back button problem and duplicate submit problem
- How to handle Ajax events and render partial responses
- How to simply data access concerns and prevent lazy loading exceptions by using flow-managed persistence
- How to secure application modules
- How to test your application logic
- General best-practices for designing and implementing navigation rules
- Techniques for achievingreuse
- Guidelines for deploying stateful navigations alongside REST-ful Spring Web MVC multi-action @Controllers
- How to implement common user interaction patterns such as master detail, wizard, and tabbed UI.

By Kito Mann
This session examines the ecosystem of products built on JavaServer Faces.

We start with a discussion of why JSF is significant and explain how it lays the foundation for a range of new products. We then look at the IDE offerings from major industry players, such as Sun, IBM, and Oracle. Next, we examine the products from smaller vendors and open source organizations, such as component suites and additional toolkits and frameworks, examining the specific features and benefits that these products provide. Finally, we look at other potential product opportunities and examine ways to get involved.

Prerequisite: Basic familiarity with web application development in Java.

By Kito Mann
The benefits of using JavaServer Faces UI components to rapidly construct complex, interactive user interfaces have become quite clear over the past couple of years. However, the standard process for developing these UI components is currently quite tedious. Fortunately, there are better solutions available.

This presentation examines techniques for easing the process of developing components with techniques such as annotations, convention over configuration, and templating. We'll examine solutions based on JSP tag files, Facelets, and Apache Shale. In addition, we will discuss how JSF 2 will simplify the process.

Prerequisite: Basic understanding of JSF.

By Kito Mann
With increased emphasis on scripting technologies, the Java platform is evolving to accommodate dynamic languages at all levels. While JavaServer Faces (JSF) provides a powerful UI component model, an adequate IOC framework, navigation, and several other features, it is not obvious how to build JSF applications using dynamic languages. This session examines how to integrate JSF with languages such as Ruby and Groovy.

We will look at how you can leverage Spring's scripting support for JSF managed beans. In addition, we will examine the native Groovy support currently available in Mojarra, the JSF reference implementation, as well as upcoming Groovy integration in MyFaces. Finally, we will discuss the future of scripting in JSF 2.0.

Prerequisite: Basic understanding of JSF.

By Kito Mann
Testing web applications, and in particular, JavaServer Faces applications, sometimes seems like a black art. For JSF, there are a couple of different approaches for unit testing. This session describes the Shale Test Framework and provides examples of how to use it.

Shale Test is a "stub" framework, which means that it provides dummy objects that work outside of a container. In addition to showing examples of using Shale Test, this session examines the future of the library and its benefits and limitations.

By Kito Mann
JavaServer Faces, the standard Java web development framework, has gained quite a few fans and detractors over the past few years. Regardless of the camp, most agree that the framework can improve. JSF 2.0, currently under development through the Java Community Process, aims to be a dramatic leap forward for the framework.

This session covers enhancements, changes, and new features currently under discussion by the JSF 2.0 expert group. These include improved Ajax support, better UI component interoperability, simpler component development, a Facelets-style template language, automatic re-deployment of application artifacts, and several other goodies.

Prerequisite: familiarity with JSF

By Martin Marinschek
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, with JavaScript enabled.

By Martin Marinschek
In this talk, you will get a short introduction to WebBeans - the
specification which will glue JSF and EJB3 together.

We will look into the features of WebBeans, how you can configure WebBeans annotation and XML-based, and how the features compare to other popular Dependency Injection frameworks, especially Spring.

By Matthias Wessendorf
This session introduces Ajax application development with ADF Faces RC by example.


The Web 2.0 paradigm has brought a new user experience to Web-based applications. One possible implementation of Rich Internet Applications (RIA) is through Ajax, a technology cocktail that includes JavaScript, DHTML, CSS and the browser XMLHttpRequest object. To bring the Ajax development experience closer to Java EE developer, Oracle has developed a set of more than 100 Ajax enabled JavaServer Faces components; the ADF Faces Rich Client components.
Truly, ADF Faces RC is Ajax for everyone and provides developers with an unprecedented declarative development experience that makes RIA development productive. This session introduces Ajax application development with ADF Faces RC by example.

By Matthias Wessendorf
This talk shows the combination of these frameworks, for creating a rich JSF application.



The Apache Trinidad project offers you more than 100 Ajax-buildin
components for an Ajax-integration, that is almost for free. It also
provides you a client- and server-side Ajax-API, for leveraging 3rd
party libraries such as Dojo or Yahoo UI. Facelets lowers the pain, when
creating view-templates or custom JSF components. You learn how to build cool Mashups and how to extract them to reusable components. The session also demonstrates an easy way of creating custom JSF components, by using popular 3rd party JavaScript libraries.

By Max Katz
The session will introduce RichFaces and demonstrate how next-generation Web applications can be built using JSF and RichFaces without any direct JavaScript coding.




JBoss RichFaces is a JSF component library that makes it simple to build Rich Internet Applications with JSF. RichFaces provides a large number of out-of-the-box components with AJAX support and skinability.

By Max Katz
This session will cover three different technologies and delivery platforms for building Rich Internet Applications: JSF/RichFaces, Flex, and JavaFX. The pros and cons of each technology will be discussed.

JSF/RichFaces components allow one to easily and quickly build pure browser-based applications. Although JSF/RichFaces has proven itself at the enterprise level, two other technologies, Flex and JavaFX, are also on the radar for Rich Internet Applications. Flex is a framework for building applications that run inside a lightweight, powerful Flash player virtual machine, which installs as a plug-in into any browser. JavaFX is a new open-source, scripting language that runs inside the new, more lightweight, but still familiar, Java runtime environment. Technical examples will be shown.

By Max Katz
This session will demonstrate a simple way to use JSF and Flex components on the same page and application while binding them to the same data model (like JSF managed beans).


JSF and various rich component libraries enable the building of sleek
and sophisticated AJAX-based RIA applications. To kick it up a notch,
Flex components can be used to create a user experience beyond what the browser allows. Flex applications run inside a Flash player virtual
machine plug-in and provide far richer experiences than the browser
alone. However, using JSF components and Flex components on the same page is a challenge today without some "plumbing" layer underneath.

By Michael Yuan
The Seam framework is one of the most popular frameworks people use with JSF. As an integration framework, Seam enriches the standard request / response model of a web application, and brings previously hard-to-integrate features into web applications.

In this talk, I will discuss some of those deep integration features supported in Seam.

* How to start and manage business processes from a web applications

* How to develop a web app that completely driven by business processes

* How to integrate business rules and security rules into a web application

* How to start a cron task for a web application

* How to run a multi-page transaction

I will provide a high level conceptual overview of each topic, and use sample code to show how easy it is to implement those features in Seam in a fraction of code that would take other web frameworks.

By Michael Yuan
In this session, I will discuss common mis-understandings of JSF's mobile web support (e.g., shall you use a different renderkit to generate WAP content?), and present a complete solution to detect the incoming device, and generate the appropriate content to optimize for the device. I will cover popular third-party libraries that are specifically designed to work with iPhone's Safari browser, and how to integrate those libraries into your JSF application.


The Apple iPhone revolutionized the mobile web landscape in the US, generating over 70% of all web traffic from mobile phones as observed by Google. To reach out to affluent iPhone users, many companies, such as Google, Amazon, Facebook, are racing to build iPhone-specific versions of their web sites. For JSF developers, this is great news since most JSF applications are already architected to separate the view from the business logic. Only a small effort is required to bring your site up to date to support the vaulted iPhone user experience.

Even though the talk is in the context of iPhone development, the techniques covered in the talk should enable you to develop web applications that target a wide array of mobile devices, and even make your Ajax site Section 508 compliant. I will address those additional points at the end of the talk.

By Neil Griffin
When a portlet form is submitted, all the other portlets on the same
portal page are forced to redraw themselves. Learn how ICEfaces
Direct-to-DOM rendering provides a cure for this disruptive end-user
experience, and how ICEfaces Ajax Push supplies a rich alternative for
inter-portlet communication. Demonstrations will be performed within
Liferay Portal, a JSR 286 (Portlet 2.0) compliant portlet container.


- Portal Technology Overview
- Explain the advantages of portal technology
- Describe what portlets are and how Liferay is an open source portlet container
- Explain the advantages of using a framework like JSF for portlet development
- JSR 127 and JSR 168 designed to work together
- List of new features in JSR 286
- Describe the new Ajax-related features of the JSR 286 spec and what it means for rich portlets

- Demo#1: Typical JSF Portlet
- Submitting a form causes an HTTP POST and a subsequent redirect that causes the browser to re-render the entire page
- Other portlets on the page are forced to re-render themselves

- ICEfaces Technology Overview
- Describe how ICEfaces makes use of Ajax in order to extend the JSF standard
- Explain the ICEfaces Direct-to-DOM (D2D) technology
- Explain the idea of partial-submit and why it is an essential feature of JSF 2.0
- List some of the rich user interface components provided by ICEfaces

- Demo#2: ICEfaces Portlet
- Partial submit provides client-side field validation for free
- Submitting a form causes incremental page updates, rather then re-rendering the entire page
- Other portlets on the page are not disturbed

- ICEfaces Extended Request Scope
- Describe how the ICEfaces extended request scope is the perfect match for the lifespan of a portlet

- Using ICEfaces Ajax-Push for Inter-Portlet Communication
- Describe how ICEfaces server-initiated rendering can be used to perform inter-portlet communication between portlets on the same page and/or between portlets in different user sessions

- Demo#3: Sample Portlets Built with ICEfaces
- Ajax Push Inter-Portlet Communication
- File upload with Ajax Push progress indicator

- Summary

- Q & A

By Scott O'Bryan
This session will provide an overview of the latest developments in the JSR-301 Portlet Bridge. The primary focus will be on the public draft which addresses Portlet 1.0 and JSF 1.2 specification, but will also cover some of the work being done to support the Portlet 2.0 specification.

This will provide an architectural overview of the current JSF Portlet Bridge being developed as part of the Apache MyFaces project as well as some ?gotcha's? that are commonly encountered when developing JSF applications for portlet environments. This session is geared toward those looking to develop portlet applications written in JSF, as well as for render kit developers looking at making their render kits compatible with a portlet environment.

By Scott O'Bryan
This session will cover advanced topics in JSF Portlet development. It is geared primarily for render kit developers and those involved with advanced application development.

It will cover topics such as AJAX in a portlet environment, alternatives to using filters for JSF Portlet logic, and bridge-optional render kit development. The topics covered will include both concrete examples based on the current public draft, and some theoretical designs which have been discussed by the JSR-301 Expert Group for Portlet 2.0.

Prerequisite: JSF Portlet Bridge Overview

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 Ted Goddard
The web has evolved from a document repository into a multi-user collaboration medium, shaped and created by its users. Ajax Push gives the server the ability to update any part of any page at any time, transforming every application into a new communication tool, connecting users to each other through web server mediated channels.

This session presents an overview of Ajax Push and its range of uses in multi-user web applications. By stepping through the development of a multi-user slideshow and chat system, attendees will learn how easily sophisticated Ajax applications can be created. The combination of JavaServer Faces and the open source ICEfaces framework allows developers and designers to focus on their application and fully apply their current skills. Attendees will take away practical information on JavaServer Faces, Ajax, Ajax Push, and ICEfaces.

By Ted Goddard
This session provides an overview of the mobile web and how the constraints are satisfied by the ICEfaces Ajax framework, and presents a number of JSF application techniques that allow both mobile and desktop users to be addressed 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.