Git Going with a Distributed Version Control System!

Matthew McCullough Ambient Ideas, LLC Tim Berglund August Technology Group, LLC

You've heard about Git, Mercurial, Bazaar and the Distributed Version Control System revolution. In this deeply hands on session, we'll load Git on participants laptops, build repositories and share out pieces of work. We'll explore the optimized agile workflows that Git facilitates, building branches for each story card and merging with our team mates, even when a network isn't present. We'll clone an existing Subversion repository, work on it in a Git fashion, and push just the "good changes" back to Subversion, showcasing the incredibly polished interoperability of this radical source code control tool. This will be a hands on session and requires attendees to bring a laptop (Windows, Linux, or Mac).

RichFaces 4 workshop

Max Katz Exadel

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

JSF 2 Ninja Bootcamp

Kito D. Mann JSFCentral

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.

Java EE 6 secrets: Wield CDI like a Ninja Master

Daniel Allen Red Hat, Inc. Lincoln Baxter III JBoss by Red Hat, Inc.

Java EE 6 offers significant and compelling improvements over previous revisions of the platform. Java EE is now portable AND lightweight. But what if these improvements still come up short for your needs? Will you have to wait for Java EE 7 to get the features necessary for you to move forward?
How do third-party technologies fit into this picture?

Regardless of how sweeping the change, before long, you'll expect more out of the platform. Java EE 6 makes room for growth.

This workshop explores the new programming model that was introduced as the foundation of Java EE 6, JSR-299: Contexts and Dependency Injection (CDI). You discover that with this programming model, it's possible to enhance, extend and customize the platform to suit your needs. You learn how you can achieve loose coupling without sacrificing strong typing and how to create portable extensions that integrate natively with the container by leveraging the extension SPI. In essence, we can backport features of Java EE 7 and beyond, effectively making them available today.

This workshop uses a blend of lectures, example code and live coding to demonstrate how to use the features provided by JSR-299 to develop applications and extensions that target a Java EE 6 container. The content is divided into four parts:

• 1. Introduction to the JSR-299 programming model
• 2. Writing portable extensions using the JSR-299 extension SPI
• 3. Testing Java EE 6 applications and extensions
• 4. Using tooling to develop efficiently and confidently

The workshop starts off with a high-level overview of CDI, the new Java standard for dependency injection and contextual lifecycle management. We visit the core programming model, study its relationship to other platform technologies such as EJB 3.1 and JPA 2, and recognize how it unifies and enhances the Java EE platform as a whole.

We then get our hands dirty by using the Apache-licensed JSR-299 reference implementation, Weld, to see these concepts in action. We also explore alternative implementations, such as OpenWebBeans, along with their Servlet container add-ons.

Next, we look ahead at using CDI extensions to enhance the Java EE platform. To prove that the Java EE platform is truly extensible, the focus is on examples rather than promises. We lay out the pool of options from which you can draw, ranging from registering custom beans, interceptors and decorators, to customizing dependency injection points, to augmenting the annotation-metadata on registered beans, to introducing custom scopes.

To solidify these options, we launch another coding session to wire these enhancements into the container lifecycle using the CDI eventing system. Having looked at some standard examples, we unlock some shortcuts and shorthands that are provided by the portable Seam Solder library. Examples are taken from the growing ecosystem of open source portable extensions.

Enhancing a platform can be risky and error prone without a good feedback loop. To eliminate hangups, we unveil the missing link in enterprise Java development: simple, portable integration tests. For many, this void has long made enterprise Java development an arduous undertaking. Arquillian, a container-oriented testing framework layered atop TestNG and JUnit, tears down this barrier. It does so by bringing your test to the runtime rather than requiring you to manage the runtime from your test. Picking up where unit tests leave off, Arquillian enables you to test real components that rely on real enterprise services in a real runtime.

Even with tests, feedback is not immediate. That's why we also explore what tooling can do to help us initiate projects and lay down valid code. The strong-typing enforced by JSR-299 takes the guesswork out of tooling and allows it to be deterministic. You witness how the CDI tooling in JBoss Tools can enforce the numerous rules defined in the JSR-299 specification in real time, detecting problems you likely wouldn't uncover until deploying the application. This saves you time and frustration.

By the end of this workshop, attendees will be familiar with the features offered by CDI (dependency injection, contextual lifecycle, configuration, interception, event notification), appreciate the value of using a type-safe programming model and the expressiveness of meta-annotations and how to use this programming model to make Java EE fit your needs.

This workshop offers an excellent opportunity to learn about the the new, JSR-299 programming model that forms the foundation of a unified, extensible Java EE 6 platform.

Audience

• Developers using Java EE who are looking to get more value from the platform.
• Developers evaluating Java EE, particularly developers who have left Java EE for competing enterprise platforms, such as Spring.
• CDI extension writers.
• Enterprise systems architects.
• Technical managers.

Prerequisites

• A high-level understanding of enterprise and modern web application development.
• Experience with the Java Platform, Enterprise Edition (Java EE)
• Basic experience with an integrated development environments (IDE) such as Eclipse or NetBeans; and build tools such as Ant or Maven.
• Frustration using Java EE of old ;)

Outline

• High-level overview of the Java EE 6 platform
• Understand what the Java EE 6 has to offer and why you would choose it for application development.
• JSR-299 programming model overview
• The concepts and APIs used to develop a JSR-299 compliant application.
• Writing portable extensions
• Make Java EE the way you want it by enhancing it with your own portable extensions.
• Saving time using Seam Solder
• Why write an extension when you can borrow one. Learn what the Seam Solder library offers, both to application developers and extension writers.
• Testing Java enterprise applications and extensions
• Use Arquillian to write simple integration tests for your enterprise application, leveraging similar abstractions offered by Java EE 6 itself
• Real-time validation, code navigation and code-test-code cycle using tooling.
• Code less, code it right the first time and continuously deploy the application using tooling.