By Andrew Glover
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. Given the automated nature of continuous integration spawned builds, software teams can now start to look at their build process as something more useful than a simple compile and test process.


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. Given the automated nature of continuous integration spawned builds, software teams can now start to look at their build process as something more useful than a simple compile and test process. Builds can be augmented with a series of Software Inspectors, which report on various aspects of software quality, such as code complexity, code duplication and code dependences to name a few. In this presentation, attendees will learn about the practice of continuous integration and the available CI tools for Java. Furthermore, Software Inspectors will be examined and attendees will learn how to interpret the data they provide and how to take actionable items based upon that data.

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 plugged into the Hudson CI server and as features are coded using Agile techniques like developer testing, attendees will ultimately see first hand how a Continuous Integration process reduces risk and improves software quality.

By Andrew Glover
There's no question that Ant is the de facto standard for building Java applications; however, even its creator has acknowledged an inherent limitation with Ant's expressiveness due to its reliance on XML. Recently, the popularity of Ruby and the Rails framework has brought to focus Ruby's de facto build platform: Rake. Rake's expressiveness comes from its reliance on Ruby itself to define a DSL for software assembly. While Rake's ultimate focus is Ruby, there are a number of interesting projects that utilize expressive DSLs for building Java including Gant, which uses Groovy as a DSL format and builds upon Ant's existing cornucopia of tasks.

In this session, we'll examine why Ant is possibly limiting and attempt to understand why Rake for Ruby is arguably more expressive-- from there we'll see Gant in action and see first hand how brining Ant into a fully functional language yields an expressiveness unmatched in XML. By the end, you'll be eager to download Gant and put your Groovy skills into action for constructing a highly flexible and extensible build system that moves concepts to cash in short order.

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 features of Groovy (including building DSLs) which have yielded the easyb BDD framework.

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 collection classes. Using these concurrency utilities will, in most cases, make your programs clearer, shorter, faster, easier to write, and more reliable. This session provides you with an overview of the new high-level concurrency utilities in the new java.util.concurrent package in JDK 5.0.

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 threads
- Build resource-management into your architecture
- Decouple identification of work from execution

Rules for improving scalability
- Find and eliminate serialization

By Brian Goetz
Performance myths about the Java platform abound, from the general "Java is slow", to the more specific "reflection is slow", "allocation is slow", "synchronization is slow", "garbage collection is slow", etc. Many of these myths have their root in fact (in JDK 1.0, everything was slow); today, not only are many of these statements not true, but Java performance has surpassed that of C in many areas, such as memory management.

In this class, we'll look at some common Java performance myths, identify where they came from, and explore the platform changes that have rendered them no longer true. Many common performance hacks don't actually help, and some can seriously hurt performance. The result is that clean code that follows common usage patterns generally shows far better behavior on modern JVMs than code laden with tweaks designed to "help" the JIT or garbage collector. More often than not, this well-intentioned assistance has the unfortunate effect of undermining many common JIT optimizations, resulting in slower -- not faster -- code.

By Brian Goetz
What's the worst thing that can happen when you fail to synchronize in a concurrent Java program? Its probably worse than you think -- modern shared-memory processors can do some pretty weird things when left to their own devices.

Java was the first mainstream programming language to incorporate a formal, cross-platform memory model, which is what enabled the development of write-once, run-anywhere concurrent classes. It is the Java Memory model that defines the semantics of synchronized, volatile, and final.

However, because the most commonly used processors (Intel and Sparc) offer stronger memory models than is required by the JMM, many developers frequently use synchronization and volatile incorrectly, but have been insulated from failure by the stronger memory guarantees offered by the processor architecture they happen to be deploying on. (The infamous “double checked locking” idiom is an example of this sort of error.)

JDK 5.0 incorporates JSR-133, a revision of the Java Memory Model, which refines the semantics of synchronization, volatile variables, and final fields. Additionally, the new JMM provides a new safety guarantee – initialization safety – that allows immutable objects to be shared among threads without synchronization, if certain requirements are met. This talk describes the updated Java Memory Model for programmers who are familiar with the multithreading primitives in Java (synchronized and volatile.)

Understanding the Java Memory model is key to using the core concurrency primitives (synchronized and volatile) to develop thread-safe, efficient concurrent classes. We’ll cover what a memory model is, what synchronization really means, what was broken about the original Java Memory Model, and how the memory model changed in JDK 5.0.

By Brian Goetz
Transactions are the software building blocks of enterprise applications, but not all transactional systems are created equally. This talk covers the basics of what transactions are, why they are essential to building reliable enterprise software, the fundamental properties of transactions, and how transactions are supported and implemented in popular frameworks such as Java EE and Spring.

Murphy's Law states that anything that can go wrong, will go wrong. And in enterprise applications, there are lots of things that can go wrong -- disks fill up or fail, systems crash, network connections go down, clumsy people trip over power cords. While you can't prevent failures from happening, you can prevent failures from corrupting your application data, and transactions are the standard way to structure application logic to enable reliable error recovery in the face of inevitable failures.

This talk covers what transactions are, the various participants in local and distributed transactions, the role of transactions in enterprise technologies such as Java EE, Spring, and Web Services, how user code communicates its transactional requirements, and the behind-the-scenes magic how enterprise frameworks hide most of the implementation of transactions from applications.

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 investment in specification that few developers can afford to make.)

FindBugs, an open-source tool developed by Bill Pugh and David Hovermeyer of the University of Maryland, has raised the bar for ease-of-use and effectiveness of automated code analysis for finding bugs. FindBugs has been able to find many serious bugs in production software, including Eclipse, JBoss, Apache Tomcat and Sun's JDK implementation, with an impressively low false-positive rate compared to other approaches.

This session will explore how static code auditing tools work, how it is easy to write bug-detector plugins to find new bug patterns, presents some common bug patterns and fun "find the bug" puzzles, and shows how code auditing tools can easily identify them.

Every developer will want to have these tools in their toolbox.

By Brian Pontarelli
This presentation covers the latest dependency injection framework named Guice. Guice was written by the developers at Google and makes dependency injection lighter, faster and easier to write. Attendees will learn how to dependency inject their classes using Guice annotations and modules.

Google's Guice is a new light-weight dependency injection framework that uses annotations and Java code rather than traditional XML configuration. Like most of the projects from Google, Guice is extremely fast and reduces latency when constructing new objects and injecting dependencies. Guice supports the most common dependency injection concepts that other frameworks providing, but in a type safe manner and without the XML.

Attendees of this presentation will learn how to setup dependency injection using Guice. This will cover a detailed description of Guice modules, which are Java classes used to configure Guice. It will also cover these topics:

- How Guice uses annotations to inject classes and how to create custom annotations
- How to inject legacy code using Providers
- How to inject different implementations of interfaces using annotations
- Injecting constants
- Injecting statics
- Scopes

Attendees should have a working knowledge of dependency injection.

By Brian Pontarelli
This talk covers the difficult subject of dependency management and uses the Savant open source framework to illustrate how to tackle some of the more difficult problems of dependency management. During this talk we'll cover the basics of dependency management, software versioning, compatibility, upgrading, and much more.

Dependency management is a difficult problem that all projects must deal with. As projects contain more dependencies and start leveraging tools that providing transitive dependencies, this task becomes even more difficult. There are only a few tools available that providing dependency management including Maven 2, Ivy and Savant. This presentation will use the Savant tool in order to illustrate dependency management and how to manage it.

This talk will cover these topics:

- Dependency management
- Software versioning
- Compatibility
- Savant project files
- Dependency resolution
- Integration builds
- Full releases

If you build software in any form and don't currently use dependency management or sometimes run into issues with dependency management, this talk it for you. It will cover all the basics of dependency management as well as more complex topics such as software compatibility and integration builds.

Attendees don't need to know anything about dependency management or have any knowledge of the tools available in order to attend this session. However, if you do understand dependency management and already use one of the tools, but still have troubles with dependency management, this talk can still provide additional insight into this complex problem.

By Brian Pontarelli
This talk will cover the basics of Struts 2, the latest version of Struts and the marriage of WebWork and Struts 1. We'll be discussing the features of Struts 2 and how developers can get up and running with Struts 2.

Struts 2 is the latest version of Struts that started a port of the WebWork framework into the Apache Struts codebase. From this foundation, Struts 2 has added a number of features not found in WebWork or Struts 1, including a plugin system that already has numerous plugins available and a number of additional features aimed at making Struts extremely extensible.

This talk will cover the following topics:

- Setting up Struts2
- Creating a simple page
- Adding an action and dynamic content to the page
- Adding a form to the page
- Adding validation to the form

Attendees need not know anything about Struts or WebWork to attend this session.

By Brian Pontarelli
This talk focuses on how developers can create Struts 2 applications with little or no configuration using the Struts 2 Convention Plugin. This plugin leverages Struts 2 plugin system and can be dropped into any Struts 2 application. We'll cover how to add the plugin to an application and start coding Struts 2 applications without configuration.

The Struts 2 convention plugin was written to help developers create applications without the burden of the Struts XML configuration files. This plugin uses a package searching method to find actions and standard web conventions to transform those actions into URLs. It also locates the JSPs or other views that correspond to actions and wires everything up without any configuration. However, when the conventions don't work, the plugin provides a number of annotations to allow developers to configure the application without XML.

This talk will cover these topics:

- Adding the plugin to a Struts 2 application
- How actions map to URLs
- Creating an Java package and action class
- Adding the JSP that corresponds to the action class
- Overriding the conventions using annotations

Attendees should have some knowledge of Struts 2 or WebWork and how to develop applications in one or both of these frameworks. Although, those familiar with other MVC frameworks will be able to grasp the concepts with little trouble.

By Brian Sletten
We write very complicated software, don't we? 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 frameworks for adding CEP/ESP capabilities to Java applications.

By Brian Sletten
As developers, we sometimes get to make choices about the technologies we use, sometimes not. We base these decisions on personal experiences, recommendations from others and a general sense of where the industry is going.

Web Services have been all the rage for several years now. We have been told time and again that we should be building systems around them; as an industry, we've never been more confused. Perhaps it is time to Give it a REST.

Part of the problem with the conventional Web Services technology stack is that it is more complex than it needs to be for small to medium-sized systems. All of the examples show how simple it all is, but how often do we really need to check the temperature or get a stock quotation? Real systems that are built out of these technologies are rapidly spiraling toward incomprehensibility, unmaintainability and (shocker) insecurity!

SOAP has a place, but so does REST, a simpler architectural style for invoking services in a language- and platform- independent way. This talk will motivate REST, explain how it fits in to other Enterprise and Web technologies and help give you some ammo for suggesting that your organization give it a REST too.

We will look at getting started with the Restlet API, using conventional containers and advanced environments like NetKernel to build scalable REST-oriented systems.

This talk should be accessible to everyone but is probably intermediate level.

By Brian Sletten
You've read the articles, the books, the Ph.D. thesis and all of the meta-commentary about building RESTful APIs, but you're still not sure where to begin.

This is an interactive session and has almost no slides. You should come prepared to discuss ideas and maybe pair program with me and everyone else in the room. Bring your ideas for open source projects that we might want to expose through a resource-oriented model. Bring your concerns about your domains that you are convinced don't fit this model.

This is not an introduction to REST. If you do not know anything about REST, please come to the "Give it a REST" talk if that is offered as well. If not, we can have a quick review, but this session is more for people who want to talk about how the ideas apply.

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 touching SOAP/WSDL/ or UDDI.

This talk will not try to convince you about using REST. If you aren't familiar with the concepts or want convincing, please come to the "Give it A REST" talk first.

By Brian Sletten
You hear a lot of talk about rich clients, but the richness they purport to provide is predicated on having access to rich data as well as a rich user interaction style. Without the right levels of abstraction, it is hard to address and link all of the data we have to care about these days. Additionally, the web sites that do support the notion of linking require you to publish your data into TheirSpace. Forget that. You want to be able to link publicly available information to sensitive information in YourSpace.

Ever since we started doing relational joins, we've looked for ways to tie data together. The problem is, the relational model is a bit tired and doesn't move at the speed of the Net. We need schemes that integrate relational data, web pages, XML files, RSS feeds and various other sources of information.



The good news is that a slew of emerging technologies are starting to make this happen. Come explore integration strategies that allow real mashups to function on both the web and the Enterprise. We can use a variety of languages and tools to link legacy data and modern content sources. We will explore resource-oriented computing as a new way of building systems that manage information spaces, not code.

We will discuss the benefits and deficiencies of XML in this space as well as look at things like JSON, RSS and RDF. We will look at research projects like Simile from MIT, metadata storage systems like Mulgara and scalable orchestration environments like NetKernel. We'll see how to create your own Yahoo Pipes-like functionality without having to publish What happens when you mix the concepts of REST with Unix Pipes and Service-oriented architectures? What happens when you leverage the power of the web as a global data source in the context of your own day-to-day activities?

The first talk will be an overview of the various topics and technologies that enable the rich data. The second talk will focus on how we can create powerful, user and data-driven applications with the rich data we've linked.

A lot of this will be new and on the intermediate to advanced side, but an open mind is all that is really necessary to catch what is going on.

By Brian Sletten
You hear a lot of talk about rich clients, but the richness they purport to provide is predicated on having access to rich data as well as a rich user interaction style. Without the right levels of abstraction, it is hard to address and link all of the data we have to care about these days. Additionally, the web sites that do support the notion of linking require you to publish your data into TheirSpace. Forget that. You want to be able to link publicly available information to sensitive information in YourSpace.

Ever since we started doing relational joins, we've looked for ways to tie data together. The problem is, the relational model is a bit tired and doesn't move at the speed of the Net. We need schemes that integrate relational data, web pages, XML files, RSS feeds and various other sources of information.

The good news is that a slew of emerging technologies are starting to make this happen. Come explore integration strategies that allow real mashups to function on both the web and the Enterprise. We can use a variety of languages and tools to link legacy data and modern content sources. We will explore resource-oriented computing as a new way of building systems that manage information spaces, not code.

We will discuss the benefits and deficiencies of XML in this space as well as look at things like JSON, RSS and RDF. We will look at research projects like Simile from MIT, metadata storage systems like Mulgara and scalable orchestration environments like NetKernel. We'll see how to create your own Yahoo Pipes-like functionality without having to publish What happens when you mix the concepts of REST with Unix Pipes and Service-oriented architectures? What happens when you leverage the power of the web as a global data source in the context of your own day-to-day activities?

The first talk will be an overview of the various topics and technologies that enable the rich data. The second talk will focus on how we can create powerful, user and data-driven applications with the rich data we've linked.

A lot of this will be new and on the intermediate to advanced side, but an open mind is all that is really necessary to catch what is going on.

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

Seam, a framework built on JSF and EJB3.0, unifies the JSF and EJB component models. Seam is a steam roller, quickly gathering market share among JSF newbies and longtime believers alike. Come see what it's all about.

This session is an introduction to Seam. If you're already using Seam, then you might want to see what else is on the schedule during this talk, because we're going to cover the basics, such as validation and data models. But if you know a little about JSF and you're curious about Seam, this talk is for you.

Prerequisite: Some knowledge of JSF is required. If you don't know what a managed bean is, for instance, then attend JSF Whirlwind before this session.

By David Geary
This talk explores the RichFaces Ajax framework, which is really two frameworks: Ajax4jsf and RichFaces components. In this session you will see how to implement low-level Ajax functionality using Ajax4JSF, and how to use high-level Ajax components from RichFaces.


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 two of the most popular open source Ajax frameworks for JSF: Ajax4jsf and RichFaces.

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.

RichFaces components is a library of components built on top of Ajax4jsf. You get basics such as toolbars list shuttles, and a MS Virtual Earth component.

In early 2008, the JSF Expert Group has begun to focus it's attention on incorporating concepts from best-of-breed JSF Ajax frameworks, such as Ajax4jsf and ICEfaces. What you learn in this session will give you both a preview, and a leg up, on JSF 2.0.

Prerequisite: Some knowledge of JSF is required, in addition to familiarity with Ajax.

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 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 some large and complex systems.

By David Hussman
Although there are many books about agile, but few provide a path for guiding you through the beginning of an agile project. Whether you are preparing for your first agile project, or taking the lead for the first time, this session will provide a guided tour filled with practical advice and a pile of anecdotes.

We will start with things to do to prepare for the first iteration: assessments, project chartering, setting up a lab, iteration 0 and creating your first backlog. From there we will move into coaching practices like fostering discussions, facilitating retrospectives, social radiators, developer manifestos, talking in tests, and more. These are the techniques that will help you lead and successfully guide a newly forming agile community.

By David Hussman
Once your agile project is rolling along, there are many bumps and roadblocks which can derail the train. Whether you are leading the project formally or informally, there are techniques you can use to keep the project alive and innovative. This session will cover skills and techniques for leading sustainable project communities.

We will walk through some basics which need to be in place and then we will move on to advance topics like maintaining a living backlog, adapting to change, growing meaningful metrics, radiating information, working with project members, anti-coaching and more. We will also discuss a collection of monitors (spontaneous pairing, ?us? and ?them?, presence of pride, emergence of leaders) used by working coaches to determine which practices to use.

Prerequisite: Leading Agile Projects: Finding Your Groove in the First 4 Iterations

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
A great team builds great software, but how do you build a great team?

Let's move beyond getting lucky and look at some key practices that will help you build your scattered cats into a well-oiled machine.

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
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
Creating and maintaining a solid automated test suite is critical to an Agile strategy, but often we're just told to "Do it." In this talk we'll look at several pragmatic strategies for creating and building your suite.

We'll examine these strategies and then look at scenarios for using them next week. This presentation will get you started whether you're starting a new project or trying to clean up an existing one.

By Jared Richardson
There are a number of great techniques you can use across technologies and projects. Come hear some of my favorites and contribute a few of your own. We'll discuss topics from DRY to creating a zone defense for your product.

In this session we'll discuss:
-grassroots process improvement
-DRY code: why and how
-establish a zone defense for your code
-tracer bullets
-test automation
-lunch and learn
-the home server
-leaving your comfort zone for fun and profit

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