Breakfast

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

Speaker

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 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.

Speaker

Kito
Mann

With the increasing availability and use of multicore processors Java developers need to acquire some understanding of the Java memory model. This is because multithread applications that work nicely on a single-core processor might exhibit "inexplicable" deficiencies when running on a multicore processor platform. The reason may be differences in the caching strategies applied by different processors. In order to illustrate the issues this tutorial explains the Java features for multithread programming. Key topics include: memory model, visibility and reordering issues, volatile and atomic variables, initialisation safety and final fields, lock-free programming.

Speaker

Angelika
Langer

After an extended milestone phase, Spring 3.0 finally went GA (generally available) in December 2009. The third generation of the framework provides comprehensive annotation-based configuration, unified expression language support, REST-enabled web MVC, and support for Java EE 6. This talk discusses the practical use of Spring as an annotation-oriented application framework, covering the component model trends as well as selected Spring 3.0 feature highlights

Speaker

Jürgen
Höller

Lunch

Scripting languages always have been one cornerstone of web programming and with frameworks like Ruby on rails it has become more popular ever since. JSF has a lot to offer in this area and more is yet to come.

The session will cover the integration of scripting languages in both the RI and MyFaces with an emphasis on the new Apache MyFaces EXT-SCRIPTING extension as the newest kid on the block to enable scripting in JSF.
A comparison about the possibilities of both extensions will be provided and also theory and demonstration examples on how to apply scripting languages in a JSF application will be demonstrated.

Speakers

Bernhard
Huemer

Werner
Punz

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.

Speaker

Andy
Bosch

                                       Seam

This talk introduces Contexts and Dependency Injection for the Java EE platform (JSR-299), the new new Java standard for dependency injection and contextual lifecycle management. The talk will cover the core programming model, explain it's relationship to EJB 3.1 and JSF 2.0, introduce Weld, the JSR-299 reference implementation, and it's servlet container extension and, finally, look ahead at how a modularized Seam 3 will tie into this new foundation.

JSR-299: Contexts and Dependency Injection for Java EE is an elegant set of new services for Java that draws upon ideas from Seam and Guice. While many of the features provided (dependency injection, contextual lifecycle, configuration, interception, event notification) are familiar, the innovative use of meta-annotations is uniquely expressive and typesafe.

Seam is a powerful open source development platform for building rich Internet applications in Java. Seam 3 will be built on a JSR-299: Contexts and Dependency Injection for Java EE core (Web Beans), which integrates with Java EE technologies like JavaServer Faces (JSF 2.0) and Enterprise Java Beans (EJB 3.1). Seam adds integrates technologies such as Java Persistence (JPA 2.0), Business Process Management (jBPM), Wicket, PDF and Excel reporting, Security and email into a unified full-stack solution, complete with sophisticated tooling.

JSR-314 (JSF 2.0) is a major update to the JavaServer Faces framework, alleviating the major usability concerns in earlier revisions and modernizing the framework by incorporating functionality such as Ajax and partial page rendering. The Red Hat expert group members recognized that JSF 2.0 stood to benefit as much from the innovations that Seam brought to Java EE as did JSR-299, and thus played an instrumental role in advancing JSF. This talk covers JSF 2.0 from the perspective of Red Hat's involvement. You'll learn about view parameters and the metadata facet, bookarkable links, conditional and preemptive navigation, bean validation integration, Ajax and partial page rendering, exception handling, and other some other minor, but important goodies.

In this discussion Dan will talk about upcoming developments in Java EE 6 including CDI 1.0 and JSF 2.0 and how they lead to Seam 3. This is a great opportunity to learn about Red Hat's plans to build on the new revision of the Java EE platform.

Speaker

Dan
Allen

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.

Speaker

Cagatay
Civici

                                       Eliminating Bugs

If static code analysis can help developers find and eliminate bugs before code is put into production, why isn’t every developer using it? We’ll consider that question, the available IDE options, and discuss what makes these tools indispensable. After a short overview of what types of bugs you may find and a brief introduction into the theory behind static code analysis, we'll investigate the practical options in IntelliJ IDEA as well as the most popular open-source plugins available for Eclipse and Netbeans, like FindBugs, PMD or CheckStyle. We'll not only look at their capabilities to find bugs, fix them automatically or let users customize the analysis process, but also the ways they integrate into the editor and assist developers when fixing the code.

Speaker

Vaclav
Pech

                                       anywhere. A reality?

Data constraints validation is a concern shared by multiple layers in applications (presentation, business, persistence and so on) traditionally leading to duplication. Bean Validation (JSR-303) standardizes validation in the Java platform. This session describes Bean Validation and shows how various layers can use the same constraint declarations and transparently validate data across the application. It also uses Hibernate Validator to demo the integration in JPA 2, JSF 2 and CDI.

Speaker

Emmanuel
Bernard

Let's explore dynamic languages, meta-programming and Domain Specific Languages in a way that is natural to Java developers. Groovy is a programming language that allows Java developers enter the sphere of dynamic languages and yet stay within the familiar boundaries of the Java world. In this talk we'll make our first small step out of the Java comfort zone and look around for what dynamic languages can offer. Using hands-on coding examples we'll cover some of the powerful syntax enhancements that Groovy adds to Java, illustrate the principles of meta-programming, use builders and create handy DSLs to speed-up our coding. The session aims to provide you with the necessary initial background information to start Groovy programming and to tune your mind towards the new horizons.

Speaker

Vaclav
Pech

So you have implemented a number of web services because you wanted to integrate your systems in a loosely coupled way. You have read a bunch of books, worked through a number of tutorials, and followed all the best practices you could find online. And now that you're done, are you convinced that your systems actually *are* loosely coupled? Unfortunately, the way web services are used by most developers usually results in the contrary: systems that are very tightly coupled. In this session we'll discuss common pitfalls, how to avoid them, and how to use web service technology to really achieve a loose coupling of systems. (Attend the workshop "Developing loosely coupled services" for a more in-depth discussion of this topic).

Speaker

Thilo
Frotscher

Rich Internet Applications

Speakers

Cagatay
Civici

Kito
Mann

Matthias
Wessendorf

Stephan
Janssen

Max
Katz

So you have all the technical skills you need, your an expert in your field, but all the JAVA sessions in the world will not help you build a better team, find the next level of performance. The highest performing teams in the world are not built by Managers and Team Leaders; they are created by the people who work in them. Created by you. Everybody wants to work in a team that is unified, focused, full of energy and fun.. So how do you get there, as a developer how do you make a difference, build the type of team you want, you deserve. In this session we look and what drives a teams success from a developers view point. We will shine a bright light on the human side of performance going beyond the text book Scrum and Agile theory and deep into the real world, with real world examples and practical advice on how you can create the teams and working environment you want. It will change the way you view your Team, Team Leaders and Managers. Look at how you as a individual can make a difference, can be the difference, the trigger for the whole team to fly higher. Not only can you make a difference, you can be that difference that takes your team to the next level and beyond.

Speaker

Shane
Harrison