Your current filters are…
by Kito D. Mann
Forget about the basics. Everybody knows JavaServer Faces (JSF) is a user interface component-based framework for developing web applications, and that JSF 2.0 is a major leap forward. In this workshop, we'll focus on the things you may not already know.
First, we'll discuss how JSF works as a stand-alone framework, and examine the benefits of integrating with either Spring or Java EE 6 services such as Contexts and Dependency Injection in Java (CDI) and EJB. Next, we'll examine the internal hooks of the framework, such as Unified expression language (EL) integration, and the multitude of event listeners and factories. We'll look at how these hooks not only allow integration with Spring and Java EE, but also allow you to implement your own extensions.
Alternative JVM languages are all the rage these days, and JSF has plenty to offer in that area. We'll look at how the Mojarra and MyFaces implementations facilitate rapid development with support for Groovy and reloading Java classes dynamically. If you're interested in Scala, don't worry -- we'll cover building JSF applications with Scala as well.
One of JSF's key benefits is the ability to use powerful, off-the-shelf Ajax-enabled user interface components that ship with free server-side integration. But a lot of development teams haven't taken advantage of this functionality to build internal component suits of their own. We'll also cover JSF 2's composite components and built-in Ajax suppor, showing how to build an internal component suite that can be used in different applications. When you finish this workshop, you'll be a true JSF Ninja.
by Max Katz
Attendees will learn everything they need to begin developing applications with JSF 2 and RichFaces. We will first start with basic Ajax features in JSF 2 such as sending an AJAX request, partial view rendering, partial view processing using the f:ajax tag. We will then move to the new RichFaces 4 and demonstrate advanced features, tags, customization and richness it adds on top of JSF 2. You will learn how the a4j:ajax extends the standard f:ajax tag as well as how to use other a4j: tags, rich: tags and skins in RichFaces. Hands-on example will be used to demonstrate most concepts and features. Workshop will cover: standard JSF 2 Ajax features (f:ajax), a4j: tags, rich: tags, client-side validation, cloud deployment, Skins
by Max Katz
RichFaces is a JSF framework with Ajax components, client-side validation, cloud deployment, skins, and a component development kit (CDK). This session will briefly cover JSF2 Ajax features and then the extra value the new RichFaces adds on top of JSF2 through its advanced features. Examples will include partial table updates, Ajax queues, client-side validation, GAE deployment, and skins.
by Kito D. Mann
Web applications are notoriously difficult test, and even though JavaServer Faces (JSF) is an excellent technology, it doesn't necessary make testing easier. If you want to go beyond black box testing, you need access some of the framework's infrastructure in order to write comprehensive integration tests and unit tests. This means that you either need mock/stub objects, or your tests must run inside the container.
In this session, we'll discuss different ways to test JSF applications, starting from outside the box with Selenium, and then moving inward by looking at tools like JSFUnit and Arquillian, as well as complete mock/stub environments like MyFaces-Test. Along the way, we'll discuss the best use cases for these tools, and point out their pros and cons.
Java EE is already the perfect solution for complex business/enterprise systems, and the improvements in JavaServer Faces 2.x provide the perfect chance to reach out to the consumer and small business market; JSF is easier to use than it's ever been before, now making it accessible to businesses of all sizes. In order to complete the user-experience, however, one must not overlook the URL.
by Ian Hlavats
This informative session demonstrates an effective strategy for JSF UI design and development based on Adobe Dreamweaver CS5 and the Eclipse IDE. Participants will learn how to create and enhance a JSF application using Facelets, the Seam Framework, ICEfaces Ajax UI components, and a MySQL database. Highlights include managed bean code hints in Dreamweaver and deploying the application to JBoss AS
by Max Starets and Blake Sullivan
Discussions of JSF performance are often long on speculation but short on specifics. This session will shine a light on (point a profiler at) this topic by breaking down sources of performance overhead in JSF applications. We will examine the impact of existing optimizations (eg. partial state saving, view root caching) and discuss opportunities for future improvement.
by Kito D. 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 support, or the built-in Facelets support, you will have to perform some upgrade steps.
After examining how JSF 2’s support for Facelets in detail, 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 Ted Goddard
Mobile applications for iPhone and Android can be effectively developed with JSF 2.0 and ICEfaces. Join this session to learn how to use Ajax Push to build a collaborative mobile application with ICEfaces 2.0.
by Kito D. 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 views with Gracelets, JRuby integration with Spring, and examine writing JSF applications with Scala.
by Jay Balunas
This sessions will get into the weeds of some of RichFaces newest and most advanced components. We'll demonstrate how to get the most out of RichFaces client-side validation, and our new push architecture with Atmosphere, including what really makes them tick. There will be plenty of tips and tricks, not to mention code. So bring your laptops and you can follow along with online source.
by Ales Justin
Google App Engine (GAE) is among the most popular cloud application platforms today, offering decent service at a low price point or even no cost at all. Unfortunately, however, its Java environment is also a fairly restrictive. For instance, you can't write files, make arbitrary network connections, or spawn threads.
This talk presents a number of tips and tricks on how to use top JavaEE specs--CDI, JPA, JSF2, and BeanValidation, for instance--within GAE's restrictive sandbox while still benefitting from the highly scalable environment it provides and maintaining portability to other JavaEE containers. We will demonstrate how CDI can be used to abstract from GAE's services and how state-of-the-art testing frameworks such as ShrinkWrap and Arquillian can be made to work with such an application.
Key takeaway is that JavaEE on GAE is not only possible, but also good engineering practice.
JSF 2.0 provides a powerful infrastructure to build RIA applications in a rapid way. Combined with PrimeFaces Component Suite, JSF 2.0 unleashes it's true power. This talk covers various topics such as PrimeFaces core, skinning, PrimeFaces Mobile, Prime Ajax Push, a Mac OS X desktop web clone, satnav enabled applications and more.
This presentation is a case study on the compatibility strength of merging the Scala programming language with CDI (JSR 299: Contexts and Dependency Injection for the Java EE platform). CDI is a Dependency Injection framework that is inspired by the Seam, Spring, and Guice frameworks. It integrates with technologies like JavaServer Faces (JSF) 2.0, Enterprise Java Beans (EJB) 3.1, the Java Persistence API (JPA) 2.0 and JAX-RS (Java API for RESTful Web Services) 1.1 and does so in a type-safe manner. Scala and other functional programming languages depend heavily on type safety. It is because of CDI’s type safety that this presentation will be valuable.
CDI is the glue of the Java EE 6 Platform, bringing each of the independent EE technologies together into a cohesive whole. However, the integration falls short in JSF, arguably where it's needed the most. Seam Faces further integrates JSF and CDI and leverages frameworks such as PrettyFaces to make JSF a full-featured web application framework and the JSF developer's life easier.
While Trinidad and ADF provide an extensive set of components, they also offer a range of APIs and services that simplify both component and application development. This session will review the best ideas from Trinidad and ADF, highlighting more general JSF development problems and solutions that are of interest regardless of your choice of framework.
With the onset of JSF 2, it's time for a fresh look at what Java development tools make up the ideal web stack. In this session you'll learn what is important from a Spring developer's point of view: What can I do with Spring and JSF 2? What is the status of the Spring Web Flow integration for JSF? What JSF 2 features are supported and what value does Spring Web Flow provide in a JSF 2 world?
by Neil Griffin
This presentation will show developers how they can deploy JSF 2 portlets within Liferay Portal via the PortletFaces Bridge. It will explore the benefits that ICEfaces 2.0 brings to portlets, including automatic Ajax and ICEpush for rich Inter-Portlet Communication (IPC). Additionally, developers will learn how to use JSF UI components from AlloyFaces and LiferayFaces within their JSF 2 portlets.
20th–23rd June 2011