Kito Mann

Presentations

Exploring the JavaServer Faces Ecosystem

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.

JSF 2.0 Preview

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.

Polyglot JavaServer Faces

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.

Getting Things Done for Programmers

If you talk to the most well-known developers, whether they're people within your organization or internationally recognized experts, you'll find something in common: they're productive. Usually, it isn't just dumb luck. More often than not, they've focused on becoming more productive. There are dozens of methodologies that claim to increase productivity, but a clear winner amongst highly productive software developers is Getting Things Done (GTD).

GTD, originally described in productivity guru David Allen's best seller of the same title, describes a set of behaviors which, when followed regularly, reduce stress and help you become more productive at the same time.

While GTD works for anyone who qualifies as an information worker, this session looks at how programmers, architects, and technical managers can apply GTD principles to improve the productivity of individuals and the group as a whole. In addition to discussing the core principles of GTD, this session also examines tools which can be used to implement the methodology.

Writing Killer JSF 2.0 UI Components

One of the key goals of JavaServer Faes (JSF) 2.0 is ease of use, and component development is a prime example: all it takes is a single file.

What does this mean? Now you can write a reusable widget with ease, whether it's a single HTML element, a reusable panel, or a powerful Ajax widget. If you can't express everything in a single Facelet template, that's okay – you can add logic with either Groovy or Java. And don't worry – JSF 2.0 lets you easily package and version resources (such as stylesheets, images, or JavaScript files) in libraries, which you can load from a JAR file, or from your web application.

In this session, we'll walk through the process of creating UI components with JSF 2.0, moving from a simple component to a more complicated Ajax widget, looking at all of the great facilities JSF 2.0 offers component developers. We'll also discuss the new Ajax JavaScript API, which simplifies the process of writing Ajax components and facilitates interoperability between different Ajax component suites.

JSF 2 in Action

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 could be improved. JSF 2.0, the latest release of the framework, is a dramatic leap forward.

This session covers the extensive list of enhancements, changes, and new features in JSF 2. These include improved Ajax support, better UI component interoperability, simpler component development, native support for Facelets instead of JSP, automatic re-deployment of application artifacts, support for annotations, and several other goodies.

Upgrading to JSF 2

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.

Facelets Reloaded

JSF 2.0 fully integrates Facelets, along with features from JSFTemplating, into the specification. This means that JSF 2.0 applications are completely free from the legacy of JSP, and tool vendors can now fully support view templates built with Facelets.

Since the release of the JavaServer Faces (JSF) web application framework, JavaServer Pages (JSP) has always been the standard approach for building page templates. However, JSP was never ideally suited for building stateful component-oriented views such as the ones used by JSF. In 2005, Facelets was developed as an alternative to JSP, built for JavaServer Faces from the ground up. In addition to providing seamless integration with JSF's component model, Facelets also provides several other features including templating and partial JSTL support.

This session examines the version of Facelets included with JavaServer Faces 2.0, looking in detail at how compositions and templating are supported. We'll also discuss features which have been added in JSF 2.0, and how the specification supports additional templating languages.