By Jeff Brown

Groovy is an agile dynamic language for the Java platform. The language and its libraries bring many things to the table to ease the process of building applications for the Java platform. This session provides a detailed run through Groovy with lots of code samples to drive home the power of the language.

Dynamic languages provide a lot of power and flexibility compared to statically typed languages. Groovy brings that power and flexibility to the Java platform in a way that is totally compatible with all of your existing Java code, tools and infrastructure. This session covers all of the fundamentals of Groovy and gives developers a whole lot of practical information they need to get started with the language.

By Jeff Brown

Dynamic languages bring a lot of interesting elements to the table for teams interested in doing Test Driven Development (TDD). Groovy lends itself very well to TDD and this session demonstrates many features of the language and its libraries that help teams build more testable systems and build better tests.

The value of Test Driven Development (TDD) has become widely accepted. The practice has extended beyond just XP teams. Good TDD practices yield high quality software and help teams maintain confidence in their software as complexity grows. The dynamic nature of Groovy makes TDD easy and fun. Groovy may be used to unit test not only Groovy code but other code as well. Testing Java code with Groovy is a snap. Learn to use the power of Groovy to test your systems.

By Jeff Brown

Metaprogramming is a key component in building truly dynamic and flexible applications with Groovy. Groovy's metaprogramming capabilities bring great new possibilities to the table that would be very difficult or just plain impossible to write with Java alone. This session will demystify a lot of the magic that seems to be going on inside of a Groovy application.

When Java developers are first introduced to Groovy one of the first things they notice is how much easier things are in Groovy compared to Java. Boilerplate code typically generated by your IDE all melts away to nothing in a Groovy bean. Creating XML is a snap, not a tangled mess. File I/O is a breeze. Those developer productivity gains are an important part of the story. However, in addition to making easy the things you are used to doing the hard way Groovy brings whole new capabilities to the party that Java developers don't even think about because you can't do those things with Java. Many of those capabilities are made possible because of the powerful metaprogramming capabilities

Prerequisite: A Thorough Introduction To Groovy

By Jeff Brown

Grails is a full stack MVC framework for building web applications for the Java platform. Grails makes web application development both fun and easy. This session covers all of the fundamentals of building web applications with Grails.

Businesses need rich web applications and developers want to be able to build those applications without the pain that usually comes along with doing so. Grails addresses these needs very well. Grails demolishes many of the pain points that Java developers have almost (not quite) become numb to after years of suffering. This session covers all of the fundamentals:

Introduction To Grails

Domain Objects

Controllers

GSPs

Custom TagLibs

GORM

By Pratik Patel

As with many technologies, the basics are easy. The hard part comes when the developer needs to do sophisticated integration, development, and testing as part of an enterprise application. A large enterprise application requires the developer to think of issues that affect the development, scalability and robustness of the application. This presentation will cover the advanced topics described below.

A large enterprise application often will have several sub-projects that each contain their own JPA persistence unit. This opens up a number of questions around how to organize the persistence units and how the code between sub-projects should interoperate. Developers will gain insight into these issues and will see a couple of solutions using live code examples.

Many enterprise applications require integration with an application server's JTA mechanism. JTA integration allows for JPA components to work with container managed transactions and distributed transactions. A typical usage scenario for JPA & JTA is this: read from a database using JPA, perform some business logic, put a message on a queue, write to the database (again using JPA). A JTA transaction allows you to ensure that the entire set of operations is committed or a rollback is performed. In this presentation, the developer will understand the limitations and configuration of using JTA and JPA together ? primarily through real code examples.

Once unit tests are written, developers

By Pratik Patel

Performance tuning any application is a black art that can consume much time. Fortunately, Java has many tools that can aid in this effort. There also are a number of basic tips that can help to analyze and fix performance problems. The Java memory model is usually something that you don't need to tune, but for high performance applications it is necessary to tweak. While there are a number of advanced things that can be done to performance tune an application, we'll discover that the simple, basic things are all that are usually needed to make your apps fly.

This session looks at how to setup and run an application with profiling tools and monitoring tools. We'll setup an application to run and put it under heavy load. While running, we'll interactively monitor it and look for problems and how to go about finding and fixing them. We'll also cover the basic issues you should look for when performance tuning.

We'll look at memory management and how to tune it appropriately. We'll also look at some of the Java 6 tools available to monitor performance and look at the JVM internals. We'll focus on the simple things that can be done right away and then look at some more advanced tweaks to identify and fix performance issues. Along the way, you'll lear

By Mark Richards

Java Persistence has come along way since the days of straight JDBC coding and custom framework development. We have at our disposal several outstanding open source frameworks such as Hibernate, Toplink, iBatis, and OpenJPA (just to name a few), and we now have a promising and emerging standards-based solution called Java Persistence API (JPA). However, all to often we find in the Java persistence space that it is a world of one-size-does-not-fit-all. We continually struggle with traditional ORM solutions like Hibernate when it comes to reporting queries, complex queries, complex relationships, and stored procedures, and we also struggle with managing the enormous amount of SQL required for solutions such as iBATIS or JDBC-based frameworks. In this coding-intensive session we will take a detailed look at identifying and overcoming the challenges we face when using frameworks such as Hibernate, iBATIS, and JPA, and how to combine the various persistence frameworks to create an effective Java persistence solution that approaches (but of course does not reach) the silver bullet.

Agenda:

- Introduction

- Framework Differences

- Brief Overview of iBatis

- Brief Overview of JPA

- Aspect Analysis

- Inserts and Updates

- Reporting Queries

- Stored Procedures

- Complex SQL

- Debugging and Testing Techniques

- The Fast Lane Reader Pattern

- Combining ORM and SQL Mapping Frameworks

- Summary and Q&A

By Mark Richards

The chances are good that at some point in your career you will need to use messaging to pass information between applications, subsystems, or external systems, particularly with service-oriented architecture on the rise. The Java Messaging Service (JMS) allows Java applications to implement messaging using a standard API, thereby removing the dependency on any particular messaging provider. In Part 1 of this session we will take a look at some of the basics of messaging, including sending and receiving messages, message types, and request/reply messaging. I will begin the session by going over the basics of messaging and the JMS API. Then, through interactive coding using OpenJMS I will demonstrate how to connect to JMS providers, send messages, receive messages, and use message properties. Please note that this is a two part session.

Agenda:

JMS Basics

- Messaging Models Overview

- JMS Message Structure

- Primary JMS Interfaces

- JMS Providers

- Internal vs. External Destinations

Practical JMS

- Obtaining a JMS Connection

- Sending a Message to a Queue

- Receiving a Message from a Queue

- Using Message Properties

- Implementing Request/Reply Messaging

- Message Correlation

By Mark Richards

In Part 1 of the JMS session I covered messaging models, messaging basics, the JMS API, and point-to-point messaging. In this interactive code-intensive session I will cover some additional JMS topics such as browsing queues, load balancing, publishing and subscribing to messages within the pub/sub model, durable and non-durable subscribers, message selectors, and message filtering. I will also discuss and demonstrate message prioritization, persistent and non-persistent messages, and finally message expiration (expiry). Note that this is Part 2 of a two-part JMS session.

Agenda:

- Browsing Messages

- Load Balancing

- Publish and Subscribe Model

- Durable Subscribers

- Message Selectors and Filtering

- Persistent and Non-Persistent Messages

- Message Priority and Expiration (Expiry)

Prerequisite: Enterprise Messaging With JMS (Part 1) or some knowledge of JMS

By Mark Richards

EJB3 (JSR-220) offers some great improvements over the prior EJB specs in terms of development simplicity and new features. In this session we will explore in detail some of the new features of the core EJB 3 specification. Included in this session will be a hands-on discussion and demonstration of session beans, dependency injection, interceptors (aop), and Message-Driven Beans (MDB). For the interceptors discussion I will be showing how to define interceptors for enabling a method trace, mocking objects, and sending JMS message notifications to be later picked up by the MDBs I will be creating. During the session I will demonstrate the new features of EJB 3 through interactive coding examples. Note: this session does not cover the new Java Persistence API (JPA) - only the core specification.

Agenda

- Introduction

- Constructing and Accessing EJB 3 Session Beans

- Dependency Injection

- Interceptors (AOP)

- Method Trace

- Mock Objects

- Sending JMS Message Notifications

- Message-Driven Beans (MDB)

- Using XML over Annotations

- Summary and Discussion

By Mark Richards

Most web-based applications rely solely on the database to manage transactions, thereby freeing the developer from having to worry about transaction management. While this works in some circumstances, there are times when the use of transactions is vital to the integrity and operations of an application and its corresponding data. In this session I will demonstrate through real-world coding examples why transactions are such a critical part of the application development process. I will review the basics of both programmatic and declarative transactions, then introduce three transaction design patterns and explain when they should be applied, how to use them, and what problems they solve. By the end of this session you will see that by using transaction design patterns you can build an effective transaction management strategy for your application with very little effort.

Agenda:

Why Transactions Are Necessary

Programmatic Transaction Management (EJB, Spring)

Declarative Transaction Management (EJB, Spring)

Transaction Design Patterns Overview

Client Owner Transaction Design Pattern

Domain Service Owner Transaction Design Pattern

Server Delegate Owner Transaction Design Pattern

Summary

By Ken Sipe

Scale... what is scale... how do you applications that are scalable. How do you know if the application scales?

This session will look at server topologies and state management and how it affects scale. We'll detail a number of metrics to know and observe. In addition tools of the trade will be demonstrated such as jmeter.

By Ken Sipe

Thoughts lead to words, words lead to action, actions lead to habits. In this session we'll sharpen the development saw in the process of understanding what makes a hyper-productive programmer. The focus will consist of developer habits and development processes.

As described in the book "7 Habits for Highly Effective People", there are habits which are characteristic of highly effective people. Clearly there are hyper-productive developers which distinguish themselves from the development pack? what is it that makes the difference? What are the habits and practices of highly effective developers?

This session will focus on individual developer habits, as well as team practices and the processes which result in high quality running software.

By Ken Sipe

You are using Java, whew!!! No need to worry about memory, the garbage collector will handle that. Those who have had a memory issue in Java are not so naive any more. Often memory utilization and heap sizes are an after thought and are not recognized until the application is in production, often caused by application uptime, production request volume or production sets of data. When the OutOfMemory Error occurs, often the science of development seems to brake down and knobs are turned. First the (-mx) maximum heap space gets adjusted... More is better right. The next OutOfMemory, heads start scratching, code reviews start in earnest, and Google gets several new hits. Did you know that it is possible to get an OutOfMemory error without running out of heap space?

This talk will walk through the underlying details of memory management in the JVM with a focus on VM flags available to help configure the VM. However we can't configure the VM without a detailed understanding of what is going on inside the VM. We'll focus on tools available for analyzing the memory in a running VM. Two actual client case examples will be presented. We'll discuss the differences between the two cases and why the end configurations were quite different.

By Ken Sipe

The success of an Agile / SCRUM project is a successful start. The first interaction is often referred to as iteration 0. Other iterations have a set of stories with clear acceptance, certain which establishes the velocity of the team and its effort. What then is accomplished in iteration 0? How do we get an Agile process started?

This session will outline all the "pre" activity tasks that lead into an agile development process. As well as the establishment of a task list of iteration 0, include the establishment of development environment, configuration management details. This will include several case histories examples of Iteration 0.

By Ken Sipe

A live Hacking demonstration exposing the tools and techniques used by Hackers.

A look at the growing space referred to as ethical hacking or penetration testing. We'll look at example attacks which include:

Client-side exploits

Sql-Injections

Brute force attacks

Man-in-the-middle attacks

Key logging

By Brian Sletten

There is a shift going on in the Enterprise. While still used and useful, the promises of the SOAP/WSDL/UDDI Service-Oriented Architecture (SOA) stack have failed to live up to their promise. A new vision of linked information is enveloping online and Enterprise users. The REST architectural style is squarely behind this thinking as a way of achieving low-cost, flexible integration, increased data security, greater scalability and long-term migration strategies.

If you have dismissed REST as a toy or are unfamiliar with it, you owe it to yourself to see what is so interesting about this way of doing things.

There is tremendous interest in REpresentational State Transfer (REST) as an architectural style for building scalable, flexible, information-driven architectures in the Enterprise. The success of the Web has caught our attention in the face of increased complexity and many failures with more traditional Web Services technologies. The problem is that it is difficult to sell a way to do things. Managers do not want to feel like they are innovating in the middleware space. They want to understand why they should deviate from the blue prints laid down by the industry leaders. They want to understand when they should use REST, when they should use SOAP and when they might fallback to regular old

By Brian Sletten

If you have started to take a look at REST as way of exposing web services or managing information spaces, you may be frustrated by the support offered by legacy containers. There is no direct support for REST concepts in the J2EE specs (yet). XML-based configurations are so 1990's. Come learn about Restlets, a little API that has caught the attention of many in the RESTafarian community.

The Restlet API was created by a guy who wanted object-level support for RESTful concepts, but didn't want to make the move to an advanced resource-oriented environment like NetKernel. He wanted his REST and conventional environments too. He also wanted a path to more modern containers that aren't tied to a blocking I/O model like the Servlet spec is.

This talk will include a brief review of REST and its primary concepts and will then provide an introduction to the Restlet API and how it supports these ideas. It will then focus on standing up a REST-oriented infrastructure using the Restlet API and a variety of other open source tools to support a publish/find/bind infrastructure without to

Prerequisite: REST (unless you are very comfortable with REST)

By Brian Sletten

How well do you understand the dynamics of your applications? In our systems, we detect when simple things happen. Customers log in, people buy things, a stock is sold at a particular price, inventory shifts locations... all of these events mean little things, but what about the larger picture? Complex events are particular patterns of simpler events that suggest something deeper is happening. Do you know how you'd discover these bigger picture occurrences? Come hear how the Esper open source software represents a new class of complex event processing (CEP) frameworks that can be added to even high volume, high transaction systems.

Trying to write software to track event occurrence is difficult to do correctly and almost impossible to do efficiently. The problem is that the higher volume and performance our systems get, the harder it becomes and the more important it is to highlight interesting or unexpected activity that isn't represented simply by a log entry.

Complex Event Processing (CEP) and Event Stream Processing (ESP) systems are emerging as a new strategy for processing and detecting complex sequences of more rudimentary events that could have bigger implications to your production systems. While commercial software is starting to add this behavior, Esper represents one of the most accessible and widely-used

By Brian Sletten

You're a good Java programmer. You understand the JDK libraries and how to use them. The problem is that many fundamental APIs don't take the bigger performance picture in mind. Garbage collection can end up killing your app if you aren't careful. Concurrency problems and contention can keep your well-intentioned software from leveraging modern hardware architecture that support multi-core and multi-cpu systems.

Who knew that simply using the standard library code the way it was designed was opening you up for performance problems in your apps?

Don't worry, Javolution has your back.

Javolution is a small (300K) API designed to bring many of the benefits of the Real-Time Java Specification (RTJS) to J2SE, J2ME, GCJ and CLDC through deliberate design decisions.

It includes re-implementations of the java.util, java.lang, java.text, java.io and java.xml to demonstrate time-deterministic behavior. It also includes a framework for testing its own performance, supporting parallel computing, communicating with C/C++ applications and a real-time object to XML marshalling framework.

Come see how you can get some of the time-determinism and concurrency benefits in either your client or server side applications. This is a fairly deep talk and is largely a decomposition of an API

By David Bock

How many times have you started a new project only to find that several months into it, you have a big ball of code you have to plod through to try to get anything done? How many times have you been the ?new guy? on an established project where it seems like the code grew more like weeds and brambles than a well-tended garden? With a few good structural guidelines and several tools to help analyze the code, we can keep our project from turning into that big ball of mud, and we can salvage a project that is already headed down that path.

This talk will talk about everything from build processes, teamwork, and project structure through versioning, release plans, upgrde strategies, package dependencies, and more. Using real-world scenarios from two projects with 12-15 people working together over a 5-year time span, this presentation will offer advice based on multiple successful deliveries of real software.

By David Bock

After months of effort, your software is done. Or is it? Very few successful projects in our industry are really 'done'... The success of the software often breeds feature requests, spinoff ideas, scalability concerns, not to mention the continued maintenance of the hosting platform, security, data backup, and so on.

In this session we will look at how to set your project up for continued agility after the bottle of champagne has been opened. Starting with good practices for configuration management, a checklist of the kinds of things for which we need to plan, and ideas for managing your 'maintenance', your project can survive its own success.

By David Bock

Most good developers eventually have the opportunity to be managers. Whether they call you the "project manager", "Technical Lead", "Lead Developer", or some other classic middle-management title, you become the 'goto' guy between management and developers. You're the guy who is expected to keep the project in-line, track a schedule, and occasionally answer the question "How's it going?", and perhaps still contribute at a technical level. So how do you do that?

So what do you do next? How do you plan what needs to be developed? How do you know if you are 'on schedule' or heading off-track? Using good ideas from a bunch of successful projects (but no methodology in particular), you will learn the basics of good project planning, execution, and tracking.

While this talk as management methodology agnostic, many of the ideas are tracable directly back to concepts from XP, SCRUM, and even RUP and CMMi. Whether you are following a management methodology or not, the ideas in this talk will be applicable to technical managers.

By Scott Davis

There are wild-eyed radicals out there telling you that Java is dead, statically-typed languages are passe, and your skills are hopelessly out-of-date. Those extremists are the same ones who don't bat an eye at throwing out years of experience to learn a new language from scratch, pushing aside a familiar IDE for a new one, and deploying to a whole new set of production servers with little regard to legacy integration.

While this "burn the boats" approach to software development might sound exciting to some folks, it's giving your manager the cold shakes right now. What if I told you that there was a way that you could integrate seamlessly with your legacy Java code, continue to use your trusty IDE and stable production servers, and yet take advantage of many of the exciting new dynamic language features that those fanatics keep prattling on about? You'd probably say, "Groovy!" I would, too...

This talk focuses on integrating Groovy with your legacy Java codebase in a way that wouldn't raise an eyebrow in the most conservative of organizations. We'll look at the dramatic reduction in line of code you can achieve by simply flipping your POJOs (Plain Old Java Objects) to POGOs (Plain Old Groovy Objects). We'll talk about calling Java classes from Groovy, and calling Groovy classes from Java. We'll look at Groovyc, the integrated compiler that manages Groovy/Java dependencies without a hiccup.

Not once will I tell you to throw out the old in favor of the new. In each case, I'll show you how to integrate the new with the old. Don't throw out your Ant build scripts; mix in a bit of Gr

By Scott Davis

This talk focuses on the ways that Groovy can turn a traditional Java developer's world-view upside down. We'll start by talking about how you can thumb your nose at The Man by leaving out many of the main syntactic hallmarks of Java: semicolons, parentheses, return statements, type declarations (aka Duck-typing), and the ever-present try/catch block. Then we'll look at features like operator overloading and method pointers that Groovy welcomes back into the language with open arms.

The bulk of this session focuses on metaprogramming with Groovy. We'll add new methods to classes at runtime -- even if they were originally implemented in Java, and even if they were declared final. (Thanks, ExpandoMetaClass!) We'll call methods that don't exist and avoid the dreaded MethodNotFound Exception. (Thanks, invokeMethod!) We'll narrowly scope our metaprogramming shenanigans using Use blocks and Categories, and then cast our changes to the wind such that every instance of a class gets our added juice.

If you are happy taking the Blue Pill, this talk is not for you. You can continue using Groovy as a slimmed-down dialect of Java -- an 'After' picture to Java's 'Before'. If, howeve

By Scott Davis

Grails is a Java- and Groovy-based web framework that is built for speed. First-time developers are amazed at how quickly you can get a page-centric MVC web site up and running thanks to the scaffolding and convention over configuration that Grails provides. Advanced web developers are often pleasantly surprised at how easy it is to break out of that coarse-grained navigation model using the native Ajax support baked into the framework.

We'll start with the solid Web 1.0 foundation that Grails provides and mix in JavaScript libraries like Prototype and Scriptaculous. (Both are included with the framework.) Grails tags like remoteLink and formRemote make it easy to asynchronously replace strategic parts of the web page while leaving the whole unchanged.

There is first-class support for JSON (JavaScript Object Notation) in Grails. You'll see how easy it is to return JSON (and XML) instead of the usual HTML using the grails.converters package.

By Scott Davis

How optimized is your website? YSlow, a FireFox/FireBug plugin, doesn't pull any punches. It gives any website an A, B, C, D, or F rating based on 14 individual analysis points. You'll be amazed (or depressed) at what YSlow thinks of your site. In this talk, we'll walk through these points step by step, learning what Yahoo! (the creator of this utility) does to keep its web properties running as quickly as possible.

These points are nicely summarized in "High Performance Web Sites", by Steve Souders (a companion book to the plugin). The analysis points that YSlow looks at are programming language, server, and web framework agnostic. The lessons learned here are really a deep look into HTTP, taking advantage of the native capabilities of the protocol -- making the Internet work for you.

By Scott Davis

Based on the book GIS for Web Developers, this talk demonstrates how you can build your own Google Maps in-house using nothing but open source software. The Portland, Oregon Transit Authority recently migrated from a proprietary web mapping solution to the suite of 100% free and open source software discussed in this book. We look at Java-based clients, Java-based servers, and everything in between. We also discuss integrating free, public domain data from sources like the US Census Bureau and the USGS. If you're looking for real-world examples of AJAX in use, you'll find it here. If you're looking for real-world examples of web services in use, you'll find it here.

We start by exploring free datasets out there in the wild. They are stored in a myriad of file formats (some proprietary, some open) and projections. Free tools like GDAL and uDig make it easy to convert them and visualize them. Once the data is normalized, we store it in a PostgreSQL/PostGIS database. Not only does the database centralize the mapping data, it opens up quite a few interesting querying capabilities.

Serving up the data is the final piece of the puzzle. We look at web services based on the OGC (Open Geospatial Consortium) standards. We use Tomcat and the GeoServer WAR to expose our data via OGC interfaces. We look at a couple of Ajax-based mapping frameworks (MapBuilder and O

By Mark Fisher

The first part of this two-part session will focus on the essentials of Enterprise Integration with Spring. The discussion will cover the enterprise integration support libraries in the Spring Framework core within the context of well-established design principles such as loose coupling and separation of concerns.

The presentation is driven by examples that progressively extend an application with various integration capabilities such as remoting, messaging, scheduling, and management. Attendees will leave with a clear understanding of Spring's core integration support and an appreciation for the benefits of using Spring's dependency injection, templates, and proxies. After this session, you will be fully prepared to explore Spring Integration, a new addition to the Spring portfolio, in Part 2.

By Mark Fisher

The second part of this two-part session will introduce Spring Integration, a new addition to the Spring portfolio. We will begin with a high-level overview of Enterprise Integration Patterns as catalogued in the highly influential book of the same name. We will then embark on a demo-driven exploration of Spring Integration to see how it enables the development of applications based on those patterns.

Patterns we will discuss include Message Channel, Channel Adapter, Message Endpoint, Content-Based Router, Message Translator, and more. We will also take an in-depth look at the APIs so that you will understand how to provide extensions while maintaining the separation of concerns that is essential for producing maintainable, testable code.

Prerequisite: Enterprise Integration with Spring, Part 1

By Mark Fisher

In this session, we will take a deep-dive into annotation-based dependency injection with Spring 2.5. You will learn how to combine annotation and XML formats, how to customize component scanning, and how to leverage Java 6 annotations within a Spring application. Since there is no "one size fits all" solution to application configuration, we will wrap up the discussion with general guidelines to consider when employing this approach.

Although XML is the most widely used format for Spring configuration, other options do exist including properties files, Spring's Java Configuration, and even Groovy builders. Spring 2.5 adds to this mix with support for Java's @Resource annotation and Spring's @Autowired annotation. Spring 2.5 also supports classpath scanning for Spring components. This session will provide a comprehensive overview of these new Spring 2.5 features for annotation-based configuration.

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

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?

This session is 90 minutes of nothing-but-Facelets, so we're going to cover a good bit of ground. You'll see all of the basics, such as templating, error handling and debugging, and some of the more advanced aspects, such as creating your own components and tag libraries.

Prerequisite: Some knowledge of JSF is essential. If you're familiar with a templating framework, such as Velocity or Tiles, that's a plus, but not required.

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 incorpor

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

The Google Web Toolkit (GWT) is truly a revolutionary framework that lets you develop Ajaxified web applications without knowing anything about Ajax or JavaScript. But the GWT goes way beyond basic Ajax by letting you implement desktop-like applications that run in the ubiquitous browser.

In this, the first of a two-part session on the GWT, you will learn about the framework and its fundamental capabilities, such as: rapid development with project and application generators; the GWT widget hierarchy; remote procedure calls; the GWT's history mechanism, including its integration with the Back button and bookmarks; and integrating JavaScript frameworks, such as Script.aculo.us, with your GWT applications.

By David Geary

In the second part of this talk, you will learn how to extend the GWT by implementing custom widgets, including a scrolling viewport and a drag and drop framework. After discussing custom widgets, you will see how to integrate database access into your GWT applications, and how to deploy your GWT applications to external servers.

You will also learn how to integrate GWT widgets into legacy applications built with web application frameworks such as Struts, JavaServer Faces, or Tapestry. The GWT is one of the most powerful Ajax frameworks on the planet, and one of the few that let you easily implement desktop-like applications that run in a browser, and because of that, it has gained incredible mindshare in a short period of time. Come to these two sessions on the GWT and see what all the buzz is all about.

By Andrew Glover

Behavior-driven development, or BDD, has attracted a lot of attention via RSpec in the Ruby community, but BDD's roots stem from JBehave, a Java based framework modeled off of the xUnit paradigm. But JBehave isn't the only framework available for Java developers-- with the advent of Groovy, new options are available for embracing BDD in the spirit of RSpec's innovative behavior based DSL.

In this session, we'll look at what BDD is, how it is an evolutionary result of Test Driven Development, and how it shifts the traditional testing vocabulary from being test-based to behavior-based. You'll also see that this subtle shift in thinking facilitates writing behavior classes first, which is the ultimate goal of TDD style thinking in the first place.

We'll examine RSpec in an effort to understand why BDD is catching on quickly in the Ruby community and then we'll study JBehave's framework for literate programming with expectations along with its Story framework for building executable user stories. With a solid understanding of JBehave, we'll probe some of the more innovative feat

By Andrew Glover

This session will walk attendees through a series of iterations on a fictional Java project where an automated build system is created that facilitates compilation, testing, inspection, and deployment. This build system is then plugged into the Hudson CI server and as features are coded using Agile techniques like developer testing, attendees will ultimately see firsthand how a Continuous Integration process reduces risk and improves software quality.

The practice of Continuous Integration facilitates early visibility into the development process by regularly conducting software builds, thus integrating disparate software pieces earlier than later, which often times minimizes the interval between when a defect is coded and when it is discovered. Often times though, Continuous Integration is thought of as a tool, which leads to a false sense of ease when it comes to adopting a Continuous Integration process.

This session will walk attendees through a series of iterations on a fictional Java project where an automated build system is created that facilitates compilation, testing, inspection, and deployment. This build system is then plug

By Andrew Glover

The spectacular success and market penetration of the iPod, Agile software development principles, Twitter, and even Google are just a few examples of minimalism in action.

Yet, there are countless counterparts to each success previously listed that, unfortunately, didn't make it; what's more, each counterpart tried to solve the same complex problem. Was it market timing, smarter people, access to capital, savvy marketing, or a combination of any of these aspects that made the difference? Or was it because when it comes to coding, design, functionality, project teams, and even testing, less is, indeed, more?

By Brian Goetz

JDK 5.0 is a huge step forward in developing concurrent Java classes and applications, providing a rich set of high-level concurrency building blocks.

Prior to the release of JDK 5.0, the Java platform provided basic primitives for writing concurrent programs, but they were just that -- primitive -- and difficult to use properly. Building multithreaded applications on the Java platform's low-level concurrency primitives posed many traps for the unwary, and many developers were forced to reinvent the wheel by writing their own classes for thread pools, semaphores, and task schedulers.

To help users create robust, scalable, and (most importantly) correct multithreaded applications, JDK 5.0 includes a rich set of high-level concurrency constructs, such as thread pools, semaphores, mutexes, barriers, and high-performance concurrent collectio

By Brian Goetz

The Java programming language has turned a generation of applications programmers into concurrent programmers through its direct support of multithreading. However, the Java concurrency primitives are just that: primitive. From them you can build many concurrency utilities, but doing so takes great care as concurrent programming poses many traps for the unwary.

Based on the principles in the best-selling Java Concurrency in Practice, this talk focuses on design techniques that help you create correct and maintainable concurrent code.

Presented in the style of Effective Java, this talk offers bite-sized items for effectively writing concurrent code, divided into three categories: writing thread-safe code, structuring concurrent applications, and improving scalability.

Writing thread-safe code:

- Encapsulate your data

- Encapsulate any needed synchronization

- Document thread-safety intent and implementation

- Prefer immutable objects

- Exploit effective immutability

Rules for structuring concurrent applications

- Think tasks, not t

By Brian Goetz

To many developers, garbage collection is black magic. Accordingly, there are is a lot of conflicting advice about what is good or bad for the garbage collector. In this talk, I look at how garbage collection is implemented in the HotSpot VM, and techniques for writing programs that exhibit good garbage collection behavior. Surprisingly, many of these techniques coincide with writing good, clean code.

This presentation covers:

- Basics of garbage collection in HotSpot

- Where the performance costs are in garbage-collected systems

- Coding techniques for reducing GC costs

- Finalization

- Techniques for tracking down "memory leaks"

By Brian Goetz

Does your program have bugs, despite unit tests, integration tests, and code reviews? You bet. Are you using static analysis as part of your QA process? If not, you're probably missing out on some bugs that can be caught before they bite your customers.

The cost of finding a bug increases dramatically the longer it lurks without being discovered. Fortunately, today?s development tools (IDEs and compilers) can identify many potential bugs within a few seconds of their creation, resulting in higher quality code and more productive programmers. However, even the best programmers can create bugs that are very hard to spot if they make it through their first few minutes of their existence.

Until recently, automated code analyzers have not been very useful for mainstream developers. Most code analysis packages focused either on stylistic issues (such as indenting and variable naming), or on formal correctness proofs (which require an investme

By Stuart Halloway

In this talk, we will explore and compare four of the most interesting JVM languages: Clojure, Groovy, JRuby, and Scala. Each of these languages aims to greatly simplify writing code for the JVM, and all of them succeed in this mission. However, these languages have very different design goals. We will explore these differences, and help you decide when and where these languages might fit into your development toolkit. For more information see http://blog.thinkrelevance.com/2008/9/24/java-next-overview.

As we reach the middle of our second decade of Java experience, the community has learned a lot about software development. Many of our best ideas on how to use a Java Virtual Machine (JVM) are now being baked into more advanced languages for the JVM. These languages tend to provide two significant advantages:

They reduce the amount of ceremony in your code, allowing you to focus on the essence of the problem you are solving

They enable some degree of functional programming style. Think of it as a dash of verb-oriented programming to spice up your noun-oriented programming.

In this talk, we will explore and compare three of the most interesting new JVM languages: Clojure, Groovy, JRuby, an

By Stuart Halloway

Dispatch takes many forms. Single dispatch, switch statements, pattern matching, and multiple dispatch all meet similar needs: Selecting runtime behavior in response to varying runtime conditions. Flexible dispatch is a key element of Java.next. All of the Java.next languages support dispatch strategies that are far more flexible than Java's single dispatch. In this talk (Part 3 of the Java.next series), I will explore how the Java.next languages (Clojure, Groovy, JRuby, and Scala) support dispatch.

For more information, see http://blog.thinkrelevance.com/2008/8/26/java-next-3-dispatch-2.

By Stuart Halloway

Over the last few years, we have taken dozens of projects to 100% coverage, and there are still plenty of things that can go wrong. We will look at examples the various problems, and show how to prevent them from infecting your project.

With an expressive language such as Groovy or Ruby and with modern test practices, 100% C0 test coverage is readily achievable. But 100% coverage is meaningless without other supporting habits and practices. Over the last few years, we have taken dozens of projects to 100% coverage, and there are still plenty of things that can go wrong.

We will look at examples of each of these problems, and show how to prevent them from infecting your project:

* Fragile mocking

* Pair bravado

* The ugly mirror

* Parallel abstraction

* Overspecification

* Underspecification

* Invisible code

* Misplaced exemplar

By David Hussman

With the growth of agile comes the need to add a new line to the Agile Manifesto: Success over Dogma. The number of people who can say agile is growing faster than the number of people benefiting from agile practices. There are now many successful agile projects, yet there are also a growing number of projects claiming to be agile but not seeing any of the benefits agile methods provide. This session will discuss successful adoptions of agile, dumb things you can do to muck it up, and more.

Just saying you are an agile project does not mean you will benefit. If agile methods are going to work for you, you will need to make them work in your culture. This session will review the healthy and no so healthy use of agile methods. Drawing from a wide variety of examples across many companies and domains, the session will provide guides for adopting or tuning agile methods that will work within your company culture and not simply in some text book. We will also cover near misses and common landmines that many agile projects encounter.

By David Hussman

Being agile does not mean living life one iteration at a time. Agile projects without a long view can run into the common design problems of the past. Planning iteration by iteration is often foolish and feeds the myth that agile projects do not think beyond a few weeks. Successful agile projects plan within iterations and across iterations. The later planning is called release planning and it is the forum where agility first engages architecture and other cross cutting concerns.

Architects who think that agile projects evolve code one test at a time are only partially correct. Agile projects review and evolve architecture with unit tests, acceptance tests, architectural spikes, and continuous review of the system's ability to adapt and respond.

There is a home for architects and architecture on agile projects, and other traditional roles, but the there are some new variations. This session will talk about the relationship of agile methods and architecture and design and how they can work together to make stronger products and systems. The session will draw on information and anecdotes will come from projects of all sizes within companies of all sizes, including so

By David Hussman

Management and agility are not mutually exclusive. Many managers are already working in an agile manner as a means to improve, produce, or simply survive. Other managers hear about projects using agile methods and struggle to find a place in the project community.

This session provides a new way to think about managing projects. Some managers will find that their existing practices and skills are supported and enhanced by the forums and metrics provided within an agile project while others will be challenged by some of the principles and practices.

From product definition to project chartering to planning, estimating, and tracking, this session will discuss practices of agile managers working on agile projects of all sizes. The session will contains a collection of interactions meant to teach, challenge, and immerse you in the managing and leading an agile project.

By David Hussman

Agile methods have cut through the noise and lighten the burden of crafting requirements documents. While this is good, it also shows clearly see that defining and guiding the creation of software products is challenging work. Most agile projects use a product backlog as a place to hold anything that will improve the product.

Creating strong product backlogs is less defined than many of the other agile practices. Backlogs contain many items: user stories, architectural spikes, investments in updating and maintaining development and other environments, and more. While it is clear that developers primarily code, it is often less clear who adds to and grooms the backlog.

The sessions covers the creation, prioritization, maintenance and grooming of a product backlog. We will cover core topics like user stories and personas, and we will also dig into the challenges of keeping a backlog healthy. We will examine various ways that project communities contribute to and draw from a backlog, and we will examines several example projects and how they have learned the best way to collaborate around the backlog to make sure the product evolves in the most valuable direction.

By Scott Leberknight

This session introduces the Hibernate Object/Relational Mapping (ORM) framework, showing the basics of persisting Java objects to relational databases. No prior knowledge of Hibernate or ORM is assumed.

Persistence is a key element of most applications, whether web or desktop. Relational databases are the defacto standard for enterprise data storage and object-oriented (OO) programming, for example in Java, is the predominant technique to build applications today. Relational databases and OO, however, are completely different paradigms. Object/Relational Mapping (ORM) seeks to bridge this gap to allow easy persistence of objects to relational databases. Hibernate is a leading ORM framework providing persistence of Java objects to relational databases. This session introduces Hibernate and covers ORM alternatives available today; getting started with Hibernate; mapping objects to database st

By Scott Leberknight

Hibernate is a very powerful object/relational mapping framework. With the vast amount of power also comes the responsibility to choose which features of Hibernate to use and how to use them, as well as things to avoid. We'll look at some real world Hibernate tips and tricks in this session.

Hibernate is one of the most popular and successful object/relational frameworks available today. In this session we'll look at some real world tips for using Hibernate effectively. Topics we'll cover include: logging and debugging Hibernate-generated SQL; using annotation mappings, ImprovedNamingStrategy, and MappedSuperclass; understanding lazy-loading and the n+1 problem; basics of performance tuning Hibernate applications; using inheritance in your domain model; managing sessions; effective use of the second-level cache; validation using Hibernate Validator; and when not to use Hibernate in an application.

By Alex Miller

Possible library and language changes for Java 7 have been in discussion since early 2007 and many things have been proposed. This talk will focus on those items that are most likely to be included and some of the more controversial language changes that might be included in a future release. For a comprehensive list of almost everything being considered, see http://tech.puredanger.com/java7.

Some examples of topics that will be discussed include:

* Java Module System

* NIO 2 (new NEW IO)

* Swing Application Framework, Bean Binding, and Bean Validation

* Date and Time API

* Fork/Join framework

* JMX 2.0

By Alex Miller

The Design Patterns book launched a revolution in object-oriented design and provided a vocabulary for OO developers to communicate their ideas. However, in some cases, patterns used blindly can lead to awkward, confusing, or hard to maintain code. It is time for some common patterns used in Java to be reconsidered so that we can derive the benefits from patterns while minimizing their concerns.

This talk will re-evaluate key patterns like Singleton, Template Method, Visitor, and Proxy. These patterns have downsides and in some cases, do more harm than good. Examples of each pattern will be give in Java and examined for clarity, testability, and flexibility. Important problems will be discussed and examples of alternate solutions will be given.

In the Singleton pattern, we'll look at problems like hidden coupling, testability, and extensibility and examine ways to use interfaces and dependency injection to avoid the need for the classic Singleton pattern. We'll also re-examine the double checked locking idiom and update it with current advice.

In the Template Method pattern will look at problems with communicating intent, composition, and API evolution and examine ways to refactor your code to use composition instead by way of interfaces, factories, and strategies.

In the Visitor pattern we'll look at how changes in data structures break existing visitors, problems with intermingling navigation and behavior, return values, excep

By Alex Miller

Terracotta is an open-source Java clustering technology. It creates a virtual, durable Java heap that is shared across a cluster of Java Virtual Machines. This is done by dynamically instrumenting bytecode at load time to intercept calls to read and write fields, and also to enter and exit monitor locks. Information about these calls is then transmitted to the Terracotta Server (which can also be clustered) and out to other nodes in the cluster as needed. The advantage of this approach is that many Java programs can be clustered without code changes by providing just external Terracotta configuration. Many performance optimizations are performed to minimize communication and locking costs. Terracotta is commonly used for session sharing in web applications, distributed caching, and distributed workflow processing.

This presentation will give an overview of the Terracotta technology, how it's implemented, and common use cases that can benefit from the technology. We will look at some code and cluster some Java applications during the presentation.

Some topics that will be covered include:

* Terracotta architecture

* Heap replication without serialization

* Distributed synchronized and wait/notify, cluster locking

* Use cases

* Example programs

By Richard Monson-Haefel

With literally hundreds of RIA products (e.g., Adobe Flash, Nexaweb, Backbase) and open source Ajax projects (e.g. Dojo, GWT, Prototype) to choose from. Picking the right RIA technology for the job requires months of research. Richard Monson-Haefel has been researching and writing about RIA alternatives for three years and has already done the research so you don't have to.

In this presentation, Richard Monson-Haefel will explain the differences between RIA alternatives and provide a framework for selecting the best product or open source project for your application. The choices for RIA technologies seem mind boggling, but after this session you'll know the market and be able to choose the right solution easily.

By Richard Monson-Haefel

An effective software architect understands that every application is different and requires unique choices regarding programming language, middleware, integration, data access, user interface design, etc. Richard Monson-Haefel has distilled knowledge from his own experience and from personal interviews with the World's best software architects to define 10 principles every software architect should know in order to be effective.

Developers aspiring to become software architects and experienced software architects a like will walk out of this session better prepared and more confident in their decisions as software architects.

By Richard Monson-Haefel

The world of desktop and web client software is about to change and for the better. Fit Clients, application platforms that combine the capabilities of Web 1.0, RIA, desktop widgets, and client/server technologies, are gaining mind share quickly and for good reason. Fit Client platforms such as Adobe AIR, Curl Nitro, Google Gears, and Mozilla Prism promise web developers the power of client/server applications, the ease of management and access of Web 1.0 applications, the cross-platform capabilities of RIA, and the holistic environment of desktop widget platforms.

Fit Clients ensure that code written to one desktop operating system (i.e. Windows, Mac, Linux) are portable across the other desktop operating systems. Without modification. Fit Client platforms promise stronger security, easier access, better performance, and a much richer experience than any desktop client technology that proceeded them. They are the future of the desktop. In this presentation, Richard Monson-Haefel, explains the advantages of Fit Client platforms and how the Fit Client platforms are having a significant and lasting impact on application development and software distribution.

By Jared Richardson

Software projects fail over and over for many of the same reasons. We'll look at some of the more avoidable problems and some solid ways to fix them, or avoid them in the first place.

We'll talk about discovering what went wrong (and what went right!) with your last project, solving code integration issues, resolving lingering quality problems, establishing automated test suites, reining in soaring project requirements and more.

By Jared Richardson

There are a number of great techniques you can use across technologies and projects. Come hear some of my favorite ways to move "beyond" and contribute a few of your own. We'll discuss topics ranging from glue languages to ditching your IDE to building your brain.

In this session we'll discuss:

- Move beyond tools

- Glue languages

- Inbox Zero

- Learning to learn

- Not being a cog anymore

- Macro Object Orientation

- Clean code

- Looking smarter than you are

- Open source tool stacks

- Tighter feedback loops

- Scripted deployments

- Scripting databases

- Virutalization

And more...

By Jared Richardson

Technical debt has long been recognized in technical circles for years, but convincing your manager to budget time to repay "technical debt" has always been problematic. Let's couch the term technical debt concept in language more familiar to our managers: credit card debt.

Like credit card debt, technical debt accumulates slowly over time, and usually takes just as long to pay off. The interest slowly builds up until you're no longer able to pay off the principle: your entire development cycle is devoted to just "paying the interest". We'll examine common types of technical debt and strategies to effectively communicating the problems, and their solutions, to your managers.

By Jared Richardson

Has your career been a random product of your manager's whims or company's needs? Never rely on your company to keep your skills current and marketable. Take control of your own career with a proven strategy.

These are solid, repeatable steps to get your career in the trajectory you want. The first step is deciding where you want to go. We'll walk through creating a long-term plan, then break it down into manageable steps. Learn to lead within your own company, then stretch out to your local, regional and national community, building your reputation as you go. From coding to writing to speaking, each step will move you closer to where you want to be: in a position of having options and in control of your career.

By Jared Richardson

An agile team is first and foremost "a team". When that gets lost in the rush to get a product out the door, the people suffer as well as the products. It's bad for the company, but even worse for the team members. We'll learn how to defuse some of the more common problems you'll run into on dysfunctional teams.

Restoring trust and providing visibility is hard once you've been burned. It's not always possible, but we'll examine concrete steps you can take to start rebuilding your trust and your team.

By Jared Richardson

Most people fear public speaking more than death, but you don't have to let it handicap you or your career. Learn solid techniques for managing yourself, your content, and your audience.

We'll cover my favorite techniques for presenting information in presentations, connecting with your audience and managing your own nervousness. From the LIP technique to the zen of power point to where to hold your arms, you'll leave this talk with everything you need to be an effective communicator.

By Srivaths Sankaran

Unsuccessful projects dominate the landscape of IT projects by a wide margin. Retrospectives are common occurrences and the advent of newer project delivery techniques hasn't proven to be the miracle cure. Some projects have lemon written all over them at the time of arrival and others just wither away for want of proper care and feeding.

This talk introduces you to a variety of project problems and how to address them. You will learn techniques that will get you off on the right foot and habits that will ensure smooth progress throughout the project's lifecycle. The net result will be a project that hits its target and a customer that is happy.

.

By Srivaths Sankaran

The Eclipse IDE has matured over several years to become quite a powerful tool with a robust plugin-based architecture. It gives commercial IDEs such as IDEA a run for their money. Yet, most developers barely scratch the surface of its capabilities. This talk will expose you to features that will greatly enhance your productivity. You will learn tips and tricks that will make you more efficient in your development activities and allow you to focus on solving the business problem at hand. Along the way you will be introduced to improvements introduced by the recent Galileo release.

.