By Ted Neward

Java5 introduced a whole slew of new features, including annotations (JSR 175), new language features (the enhanced for loop, generics, static imports, and more), new library support (java.lang.instrument, among others), and some interesting enhancements to the virtual machine itself.

This presentation will go over those features, explain why they matter, and how you can take advantage of them in a variety of different practical ways. (For an audience comfortable with Java 1.4, as a 90-minute or half-day presentation.)

By Ted Neward

Managing state--both transient state (like your shopping cart) and your durable state (like your order placements, your inventory management forms, and so on)--is tricky in an enteprrise application. In this talk, we'll examine some of the trickiness, both high-level and low-.

We'll talk about the various forms of data persistence, including "procedural-first", "relational-first" and "object-first" approaches. We'll also talk about the costs of data-access logic, and ways to mitigate those costs. In short, if you store or use data in an enterprise Java application (be it J2EE or Spring or otherwise), you'll want to be here.

By Ted Neward

There's a lot of talk about web services, and most of it falls into one of two categories: lots of low-level talk about vendor-specific tools and extensions, or lots of high-level talk that never shows you a line of code. XML services aren't that hard, and in this talk, we'll see how, why and when to do one.

We'll talk about XML (and why it's the format used), Schema (and the core subset of Schema to focus on using, along with tools to help work with Schema more easily), SOAP (and why it's really crucial to making XML services work), and more.

By Ted Neward

Mustang, the Java6 release, is out, and even if you're not looking to adopt the new platform right away, it's important to know what's there so you can start to plan for it. In this presentation, we'll go over the major new features of the Java6 platform, including the new integrated XML services capabilities (JAX-WS and JAXB), dynamic/scripting language support (javax.script), new JVM "attach" capabilities, new annotations supported by the javac compiler, and more.

For an audience comfortable with some prior Java experience, preferably familiar with Java5.

By Mark Richards

There has been a significant amount of buzz in the community and industry about the definition and role of an Enterprise Service Bus (ESB), particularly within the area of Service-Oriented Architecture (SOA). In this product-agnostic high energy session we will take a step back and consider whether we really need an ESB. Through real-world application and architecture scenarios we will see where an ESB would be helpful and where it would be overkill. We will take a look under the hood and find out just what an ESB is really doing, and take a quick look at JBI (JSR-208) and see the impact it has on the ESB worls. Then, using product-agnostic coding examples we will learn what an Enterprise Service Bus is supposed to do, then answer the question about whether the ESB is just a bunch of hype or if we really need it.

Agenda - Introduction - Handling Distributed Services Today - ESB Alternatives - Services - ESB Capabilities - Rolling Your Own: Possible Java Implementations - ESB Use Cases - JBI (JSR-208) - Summary and Q&A

By Mark Richards

As companies continue to change the way they do business, so must the IT systems that support the business. Changes due to regulatory requirements, competitive advantage, mergers, acquisitions, and industry trends require flexible IT systems to meet the demands of the business. Software Architects must therefore make their architectures more agile to meet the flexible demands of today's business. Through real-world examples and scenarios we will explore some of the challenges facing Software Architecture and discuss several concrete techniques for applying agility to both the architecture process and the technical architecture itself. We will also look at various architecture refactoring techniques, and discuss the pros and cons of each. By attending this session you will learn how to apply various agile techniques to improve your architectures and overcome some of the challenges facing software architecture in today's ever-changing market.

Agenda: - Introduction - Part One: Applying Agility to Architecture (Interactive) - Part Two: Agile Methodologies - FDD - Part Three: Agility and Architectural Refactoring

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

In addition to providing a simplified API, the new EJB3 specification (JSR-220) defines a standard ORM Java Persistence API (JPA) that is rapidly gaining in popularity. As you will see in this session, JPA bears a striking resemblance to popular ORM solutions like Hibernate and Toplink. In this session we will explore in detail the new Java Persistence API offered by JSR-220. We will start by discussing the overall design and architecture of the JPA and how the major components within JPA interact. We will then look at defining mapping objects (entities) and how to use the EntityManager to manage these entities. Through interactive coding examples we will investigate the pros and cons of detached entities and merging, how to map and use entity relationships (1-1, 1-N, N-1, and N-N), discuss Lazy Loading, and finally see how to use XML mappings rather than annotations. More advanced features of JPA will be covered in a separate session.

Agenda - Introduction - JPA Framework Overview - Defining and Mapping Entity Objects - Managing Entity Objects (EntityManager) - Detached Entities and Merging - Entity Relationships - Lazy Loading - Using XML Mappings - Summary

By Nathaniel Schutta

Seemingly overnight, Ajax has gone from an obscure acronym to, well, having conferences devoted to it. People are often surprised when they learn that Ajax isn't really anything new - so if it's yesterday's technology, why all the hype? This talk will examine the course of events that led up to the current love affair with richer client applications. We'll talk examine the technologies that power an Ajax application and discuss how to work with them - and then we'll examine a number of frameworks that will do much of the heavy lifting for us!

Once we understand the techniques of Ajax, we'll touch on where (and where not) it's appropriate for your application finishing off with some common gotchas.

By Nathaniel Schutta

While some companies have the luxury of a full time usability team, most of us have to make do on our own. Sure, it might be easier (and more comfortable) to focus on all the hip back end goodness, but if your user interface makes users yack, your product is doomed.

This talk will provide an overview of usability from the perspective of the software engineer.

By Brian Sletten

REST sounds like such a simple thing. But, what is it really? How do you convince your boss to let you try it when she has been sold on the equation SOAP = SOA + P(rofit)? How do you go about building, deploying, publishing and orchestrating web services without the (Un)Holy Trinity of SOAP, WSDL and UDDI?

This talk will thoroughly examine this REST phenomenon in terms of its history, its goals, its consequences and where it fits into the Big Picture of SOA. We will also look at exposing existing tools/APIs through RESTful APIs.

If you find yourself interested in talking about REST without people dismissing it as trivial (yeah, but what is it?!?!), unsaleable (yeah, but I am trying to solve problems, not buy tools!) or not SOA (<insert your own joke here -- that one leaves me speechless>), come on by.

By Brian Sletten

Just about every modern software developer has a copy of the Gang of Four "Design Patterns" book sitting on a shelf; many of them have actually read it. The dark secret of the patterns community is that there is often a large gulf between whiteboard simplicity and real-world complexity. Language choice plays a part in the design (and even importance) of patterns. The situation is made even more confusing by the fact that many of the core patterns have now been "voted off the island" for one reason or another. This talk will give a pragmatic overview of the motivations behind design patterns and will focus on applying a handful of the GOF patterns to example scenarios in Java, Ruby and C#. A quick introduction to the role AOP plays in changing the patterns landscape will also be covered.

Attendees will learn about
The benefits and history of patterns in software
How language choice affects pattern implementations
Applying a handful of GOF patterns in code examples
Why there is no DP4J available

Rating: Intermediate
Category: Architecture/Languages, Core Java, .NET
Prerequisites: Basic Java or C# skills

By Brian Sletten

Imagine the simplicity of REST married to the power of Unix pipes with the benefits of a loosely-coupled, logically-layered architecture. If that is hard to imagine, it may because the architectures available to you today are convoluted accretions of mismatched technologies, languages, abstractions and data models.

NetKernel is a disruptive technology that changes the game. It has been quietly gaining mind share in the past several years; people who are exposed to it don't want to go back to the tired and blue conventions of J2EE and .NET. Not only does it make building the kinds of systems you are building today easier, it does it more efficiently, with less code and a far more scalable runway to allow you to take advantage of the emerging multi-core, multi-CPU hardware that is coming our way.

Come see how this open source / commercial product can change the way you think about building software.

NetKernel makes the things you are doing now easier, but also makes new types of systems possible.

A wise man once said, "XML is like lye. It is very useful, but humans shouldn't touch it." If you've had to incorporate XML into your project by hand, you have probably been burned by getting too close. NetKernel turns this wisdom on its head and encourages you to use XML like the liquid data stream you want it to be.

But, XML is only part of the story. Resource-oriented computing is a generalized and revolutionary approach to modern, flexible systems. There is less code to write, but it is more fun to do. Orchestration of existing services and data sources is faster, easier and more encompassing than with more conventional technologies.

This talk will help explain what NetKernel is (app server? pipeline tool? embedded SOA?) and, through a comprehensive set of examples, give you a glimpse at a deeper software reality than you might have thought possible.

Disclaimer: There will be no blue pills given to you to make you forget what you have seen. Come with an open mind.

By Brian Sletten

Most people new to Aspect-Oriented Programming (AOP) are fed up with separation of concerns zealots explaining how great their techniques are at dealing with... logging. Ok, you get it. Logging is a cross-cutting concern that can be appropriately modularized. What else does AOP have to offer? A lot, it turns out. This talk will give an introduction to the motivations of AOP as well as a series of concrete examples drawn from enterprise and client side Java. Come learn how AspectJ-flavored AOP can begin to benefit you immediately either in development or production environments. Learn how to enforce architectural policies, find Swing threading issues, reduce the invasiveness of the Observer design pattern or even improve the reusability of your domain models. Now that Spring 2.0 provides support for AspectJ, the time has never been better to learn about these new (but backwards compatible) ways of thinking about building software.

Attendees will learn about
The history and reasons behind AOP
Development-oriented aspects that can be useful, but compiled out of production code
Production-oriented aspects that can simplify development and ease the burden of future changes
Basic AspectJ usage and jargon How to use AspectJ with Spring

Rating: Intermediate
Category: Architecture/Languages, Client Side Java, Server Side Java Prerequisites: Basic Java. Some level of AOP understanding is helpful, but not required. The pace of the introduction will depend on the average level of exposure the audience has previously had to AOP.

By Venkat Subramaniam

As a Java developer, you have taken the time to learn the basics of the language and relevant parts of its rich API. However, you need more than that to develop serious industrial strength applications. In this presentation, the speaker will introduce you to a number of open source tools which you can use to improve your application quality and your development process.

Instead of simply going through a laundry list of tools available, the speaker will engage you with motivation to use these tools, and show examples of their practical use.

We will start by looking at tools for unit testing and creating mock objects. We will then take a look at tools that will help you to ensure certain performance of your critical code.

You know writing good code is more than simply using an OO language. We will look at tools that will help you with code metrics, so you can analyze, and refactor your code to reduce coupling and undesirable dependencies.

But, what about hidden critical errors in your code, like synchronization problems that may potentially lead to deadlocks? We will look at how you can use open source tools to proactively eliminate these from your code.

Finally, we will look at tools available for automating your project and getting extreme feedback though out the development cycle.

By Venkat Subramaniam

Rule based programming allows us to develop applications using declarative rules. These can simplify development in applications where such rules based knowledge is used for decision making.

In this presentation we will take a look at the tools and techniques for developing rule based applications. We will take a look at open source tools, discuss their strengths, capabilities, and limitations.

By Venkat Subramaniam

You have worked on software projects with varying degree of success. What were the reasons for the success of your last project? What were the reasons for those that failed? A number of issues contribute to project success - some non-technical in nature. In this presentation the speaker will share with you practices in a number of areas including coding, developer attitude, debugging, and feedback. The discussions are based on the book with the same title as the talk.

In this session you will learn about practices beyond what well know methodologies prescribe. While we reemphasize some popular practices, we will also discuss other often overlooked, but important practices - practices that contribute to success of projects.

By Venkat Subramaniam

Refactoring is one of the core practices in Agile Software Development. Refactoring is based on some core principles that apply to more than writing good code. But, what's refactoring? Why should you do it? How do you go about doing that? What tools are available to successfully refactor your App?

In this presentation we will address each of these questions. We will take an examples based approach to look at code that can benefit from refactoring. We will discuss how to identify a case for refactoring. Then we will use tools to help us refactor.

By Venkat Subramaniam

Inspired by the Ruby on Rails project, Grails brings the ease of web development and "convention over configuration" to the Java platform. We will learn how to create web applications using Grails, how to integrate it with Hibernate, and how to Ajax it, all using the built in features of Grails. This section assumes that you are familiar with Groovy or you have attended the “Groovy for Java Programmers” session. The session will be example driven with live coding where we will build a web application from scratch.

In this session you will learn *How to create web application using Grails * Understand Grails Conventions * Learn how to use the code generators and how to manual create domain models, controllers, and view * AJAX your application * Integrate with database

By Clinton Begin

This presentation will focus on database challenges that object oriented developers often face in an enterprise environment. Object Relational Mapping (ORM) tools are not ideal for all databases, and therefore alternatives such as iBATIS must be sought.

First and foremost, we'll show a very simple example of how iBATIS works. Just to be cool, we'll do it with AJAX (access the database from JavaScript! Oh my!)

Then we'll focus on using the iBATIS Data Mapper to achieve similar advantages as provided by an ORM tool, but without some of the complications that can arise from an object relational mapping approach. The iBATIS Data Mapping framework is a popular alternative to ORM tools, while being a complementary addition to any architecture.

By Clinton Begin

By jumping from Java to Ruby and Ruby on Rails, are we throwing the baby out with the bathwater?

In this discussion, we'll discuss the benefits of Ruby and Ruby on Rails and the drawbacks of the way we currently build Java applications. Then we'll show you exactly how the situation can be corrected, and possibly even reversed. Can the Java platform achieve what Rails does? I'm going to risk saying: "Absolutely the most important parts can."

There's a lot of buzz in the air, and very little has anything to do with Java. Java's old and boring, right? So what are people talking about, .NET? No, luckily Java's #1 commercial competitor is also old and boring (already). The new topic of the day is dynamic languages, and sitting in the speakers chair is Ruby, the hot new (12 year old) scripting language, and the Rails web framework. Together they achieve huge productivity gains, clean, readable code, simple solutions, easy deployment and portability!

Wait a minute. Isn't that what Java claims too? Or did claim years ago? So what has happened to our beloved language? Here's what: We got stupid. Is Ruby better? No. Is any language better than any other? Perhaps in some cases, like pretty much every language is better than Visual Basic, including BASIC. ;-) But aside from that, many of the benefits of Ruby have nothing to do with the language, just like a lot of the overhead we experience in Java-Land have nothing to do with Java. So what's the problem? We've forgotten how to write good software. Instead, we choose to blindly follow "best practices" and "patterns" and by stuffing what used to be good code into reams of XML and annotations.

By Clinton Begin

Agile methodologies such as eXtreme Programming and SCRUM are hot topics today -- and they are also hot targets. When things go wrong on an agile project, it's far too convenient to blame the methodology.

It's often the case that the methodology is blamed, instead of the people charged with implementing it correctly. In this talk Clinton will discuss the most common reasons a team may fail when trying to execute a project using an agile methodology. He'll cover how to learn from the mistakes of others, and avoid repeating new mistakes of your own.

By Scott Davis

Frameworks? We don't need no stinkin' web frameworks. OK, so maybe that's overstating the case. Web frameworks do plenty of good things, but sometimes they can also be golden handcuffs. Too many web developers fall into the trap of thinking, "If it can't be done by my web framework, then it simply can't be done."

This presentation focuses on the cool things that you can accomplish by stepping out of your web framework and getting closer to the underlying technology. We'll take a detailed look at what really goes on during the request/response cycle, and how new techniques like AJAX allow you to break the mold. We'll look at the clever things you can do with MIME types, User-Agents, and HTTP Headers in general.

Old technologies like CSS, DOM, and JavaScript are experiencing a renaissance under the guise of new names like DHTML and AJAX. Google Maps and GMail are literally redefining our expectations of how rich a web application can be by using these technologies to their fullest potential. Come see what makes these sites tick, and how you can utilize the same techniques in your own site.

By Scott Davis

Mark Twain once said, "Everyone talks about the weather, but nobody does anything about it." Do you feel the same way about Unit Testing? Are you actively testing your code, or are you just thinking about testing your code... some day... once you get some more free time...

Unit testing offers benefits beyond the obvious. A happy side effect of writing unit tests is that your code ends up being better architected. By forcing you to be a consumer of your own code outside of the context of the main application, you end up seeing your code in a different light. Hidden dependencies get flushed out early. Good unit tests force your code to be more loosely coupled and highly cohesive.

This presentation is a survey of the testing ecosystem. A good testing infrastructure should include more than just JUnit. Cobertura, a test coverage tool, shows you how much of your code base is being tested. Writing test cases in Groovy adds a measure of flexibility that makes working with XML (and string data in general) a piece of cake. EasyMock allows you to test interfaces instead of implementations (and also avoid having to hand-code and maintain your own mock objects). We'll also look at functional testing libraries like HttpUnit, DbUnit, and JUnitPerf that allow you to test how your code behaves out in the wild, interacting with real subsystems instead of just mocks.

Most importantly, you'll see these tools live in action -- real code examples instead a simple slideware overview. Rather than looking at each tool in isolation, you'll see how they interact and complement each other. Rather than just talking about testing, we'll (finally) do something about it.

By Scott Davis

Hopefully your test plan involves more than, "Well, it compiled..." JUnit is fast becoming a required part of the modern Java developer's toolkit. Unit testing your Java classes is a great start, but your test plan shouldn't stop there.

This talk will introduce several additional testing tools for the web developer -- HttpUnit, Canoo WebTest, and JMeter. These tools allow you to test a live website with no changes to the production code. Even better, you can test sites that have been implemented in technologies other than Java.

You will see code examples and live demos of these tools in action. We'll talk about the differences between unit testing, functional testing, and performance/load testing. Come get "test infected" -- you'll never look at the development process the same way.

By Scott Davis

In this talk, we'll survey the web services exposed by leading websites (Google, Yahoo, Amazon, eBay) and discuss how they are driving the AJAX revolution. You'll see examples of RESTful, SOAP, and JSON web services, as well as the strengths and weaknesses of each.

Everyone seems to be talking about AJAX and Web 2.0 these days. While the UIs of AJAX-enabled websites such as Google Maps and Flickr are undeniably cool, they wouldn't exist without a strong SOA/Web Services infrastructure behind the scenes.

"Web Services" is an overloaded term. While SOAP is a mainstay in the web services world, there are other equally valid flavors (REST, JSON) that accomplish the same goal -- decoupling the data from the presentation layer, the platform, and even the programming language used.

Rather than talking about web services in the abstract, this talk shows examples of each flavor of web services as it is used in the wild by leading web companies. They have all taken slightly different approaches to the same problem. We'll compare and contrast their public-facing offerings.

There is no one "right way" to expose your API via web services. After this talk, you should have a better idea of the relative strengths and weaknesses of each variant.

By Scott Davis

The release of Google Maps was a "Wizard of Oz / Technicolor" moment for web developers everywhere. It didn't just change the way we look at mapping sites; it forever changed the way we look at all web sites. It put AJAX on the map, both figuratively and literally.

Based on the book Pragmatic GIS, we deconstruct the mechanics behind Google Maps, showing you the magical combination of JavaScript and CSS that allows it to work. In 12 easy-to-follow steps, we take you from static HTML all the way to your own "slippy map", complete with zooming and different map types.

Even if you don't have immediate plans to add maps to your website, come look at "the man behind the curtain". The hands-on, practical approach to learning AJAX in this talk will pay you dividends. The pretty map you get at the end is just the icing on the cake.

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

In 2005, JSF hit its stride, as evidenced from overwhelming support from both vendors and the open-source community. JSF 1.0 had plenty of holes, but open-source projects have arisen to address those needs. This session takes a look at three of those projects: Tomahawk (MyFaces component library) FaceletsSeam

MyFaces is an open-source implementation of the JSF spec. In addition, MyFaces developers got a little carried away and also developed a useful set of custom components that you can use in your own applications, regardless of whether you use MyFaces as your JSF implementation. Those components are now packaged separately from MyFaces under the name Tomahawk.

Facelets is an open-source project from java.net that lets you implement views with Tapestry-like HTML pages. That technique is a powerful feature that lets graphic designers and software developers work separately in parallel.

Seam is a framework from JBoss that provides a component model that unifies the EJB and JSF component models. Seam makes great use of annotations to meld EJBs and JSF components in a seamless fashion (thus the name).

Lots is happening in the JSF space. Come to this talk and learn about these three exciting open-source projects.

By David Geary

JavaServer Faces is a well designed user interface framework, but it lacks a number of features you might otherwise expect out of the box; for example, JSF does not explicitly provide support for client-side validation.

So, from the folks that brought you Struts, comes Shale, a collection of useful enhancements to JSF. A top-level Apache Software Foundation project, Shale adds some really cool features to vanilla JSF, including:

Web flow: script dialog flow Remote Method Calls: easily call JavaBean methods from JavaScript Tapestry-like views: code views in pure HTML Use Apache Commons Validator validators on the client or server, or both JSF testing framework: mocks for easy JSF testing

There's a lot of cool stuff in Shale that makes JSF a much more compelling proposition. Come see what it's all about.

This is a code-intensive, fast-paced look at Apache Shale. Forty-plus slides and five demos makes for an action packed session that illustrates the cool features that Shale provides.

By David Geary

JavaServer Faces is a perfect platform for implementing Web 2.0 interfaces with Ajax. This session explores how you can use these two potent technologies--JSF and Ajax--together to create applications that look and behave like desktop applications but run in the browser.

JavaServer Faces, with a mature component model and flexible lifecyle, is a perfect platform for implementing Web 2.0 user interfaces with Ajax. This session explores using JSF and Ajax to create applications that act like desktop applications but run in a browser.

We'll start with a quick look at implementing basic Ajax in a JSF application. Then, once your bloodthirst has been slaked, we'll dive deeper into Ajaxian Faces dynamics with a form completion demo that requires its implementor to understand two simple, but vital facts about JSF.

If you're savvy, you probably use client-side validation to augment your server side validation logic, which parenthetically, is no no-brainer in either of the leading web application frameworks, JSF or Rails. But anyway, client-side validation is old school. All the cool developers nowadays use Ajax to implement realtime validation, where you sneak a trip to the server as an unwary user types into your input fields. But to accomplish that, we'll have to dive even deeper into JSF, with concerns such as accessing view state and accounting for client-side state saving.

All of this Ajax development is great fun, but most of it is best relegated to components and frameworks, which are the topics that will wrap up our session. We'll see how to keep your JavaScript separate from your JSF components and how to pass JSP tag attributes all the way through to JavaScript. Finally, we'll take a look at Ajax4jsf, a JSF component library with a tag library that blends Ajax into JSF in a natural, intuitive way without having to write JavaScript.

As web developers, we've been handcuffed long enough by the shackles of Web 1.0 development. Come to this session and see the brave new world of Web 2.0 development with one of the hottest web application frameworks.

By David Geary

Developing highly interactive web applications, for the most part requires knowledge of a wide array of technologies: HTML, CSS, JavaScript, XMLHttpRequest, JSP, JSF, etc.

With the Google Web Toolkit (GWT), Google turns that notion of development on its head. Instead, you implement Ajax applications by writing almost entirely in Java. You use an AWT-like API, which the Google compiler compiles to JavaScript that runs on the client.

In the early days of Java, application development with the AWT was relatively simple. You had to have a decent understanding of Java and AWT fundamentals, but once equipped with such knowledge, you could dive in and develop some impressive applications.

Ten years later, we have, in so many respects, gone significantly backwards. We've shoehorned technologies such as HTML into shoes for which they were never intended, and for our efforts, we have a mismatch of disparate technologies that one needs to knit together for a truly interactive web application.

This is the first session of a two-part presentation on the GWT, where I'll concentrate on GWT basics: implementing Ajax-enabled applications in Java, internationalization, testing, and remote procedure calls.

By Andrew Glover

It has been said that Grails is the addiction and Groovy is the drug. If you want to start building slick web applications rapidly with Grails it helps to start with a solid understanding of the Groovy language itself.

It has been said that Grails is the addiction and Groovy is the drug. If you want to start building slick web applications rapidly with Grails it helps to start with a solid understanding of the Groovy language itself. In this session, we'll go over the basics of the language by focusing on the core of Groovy. We'll look at Groovy collections, Groovy's interaction with Java, creating Classes in Groovy, Groovy's MOP and much much more. By the end, you'll be a Groovy expert ready to embrace all the language has to offer.

By Andrew Glover

What makes Groovy particularly appealing with respect to other scripting platforms is its seamless integration with the Java platform. Because it's based on the Java language (unlike other alternate languages for the JRE, which tend to be based on earlier predecessors), Groovy presents an incredibly short learning curve for the Java developer. And once that learning curve has straightened out, Groovy can offer an unparalleled rapid development platform.

What makes Groovy particularly appealing with respect to other scripting platforms is its seamless integration with the Java platform. Because it's based on the Java language (unlike other alternate languages for the JRE, which tend to be based on earlier predecessors), Groovy presents an incredibly short learning curve for the Java developer. And once that learning curve has straightened out, Groovy can offer an unparalleled rapid development platform.

The secret to Groovy's success, in this regard, is its syntax, which is Java syntax, but with far fewer rules. For example, Groovy doesn't require semicolons, and it makes variable types and access modifiers optional. Moreover, Groovy makes use of the standard Java libraries you're already familiar with, including Collections and File/IO. And, finally, you can utilize any Java library from within Groovy, including JUnit.

The fact is, Groovy's relaxed Java-like syntax, its reuse of standard Java libraries, and its rapid build-and-run cycle make it an ideal candidate for rapidly developing unit tests. But don't just take my word for it; let's see it in code!

By Andrew Glover

No one will argue that JUnit has positively affected the quality of thousands of Java applications around the world. JUnit’s simplicity and ease of use ushered in a whole new era of code quality; however, as many developers have found, its simplicity has also limited its use. TestNG was designed from the ground up to overcome some of JUnit’s limitations; moreover, TestNG’s features make it a great tool to complement your JUnit tests.

In this session we’ll learn about TestNG’s flexible fixture model, its test categorization capability, dependent methods, and TestNG’s powerful parametric testing facility. We’ll also see how both TestNG and JUnit can play together in a build process.

By Deborah Hartmann

Some Agile teams are still using Waterfall metrics, others aren't measuring anything at all. There's little help to be had: few hard-and-fast Agile Metrics have emerged as effective measures. This might seem surprising, but perhaps the temporary and contextual nature of agile metrics explains the emergence of a more heuristic approach.

The best teams are creating metrics on demand, in support of their goals, applying their understanding of Agile principles and values to create useful measurement tools on the fly. We propose to call these local, contextual measurement tools diagnostics to distinguish them from more long-term metrics used to measure contribution to overall organizational goals.

Since Team metrics or diagnostics are highly contextual, they need to be evaluated carefully to know if they are useful. We will present both long term metrics used by the business, and potential diagnostic measures used by the team. We will present a tool for evaluating diagnostic metrics for Agile teams, and use it to evaluate a few team metrics proposed by participants.

Since Team metrics or diagnostics are highly contextual, they need to be evaluated carefully to know if they are useful. Rather than present specific metrics, I'll talk about how to align long term metrics used by the business with diagnostic measures used by the team. I'll then present a tool for evaluating diagnostic metrics for Agile teams, and we'll use it in small groups to evaluate metrics proposed by participants.

By David Hussman

The participants of this session will become agile customers and product owners, using personas to create stories for a sample product development.

The questions around user stories are many, and the list grows larger as their popularity of increases. Many organizations are on their path to adopting stories as requirements vehicles, possibly struggling with story writing as well as finding a way to fit them into their organization. Along with writing stories, this session will cover connecting with product owners and a short review of several tools for tracking and managing user stories.

By David Hussman

This session will focus on tools and techniques for tracking an agile project plan from creation to project completion.

As agile grows, so too do the questions for how to track and communicate progress within the project community as well as to upper management and others interested in progress. We will create a simple plan in a planning tool, and run a mock project, showing how to estimate and use agile planning to communicating progress, addressing missed estimates, scope modifications, and more.

By David Hussman

The presentation will briefly discuss stories, the origin and authoring of story tests, and a demonstration of how FIT and FitNesse (FIT living within a Wiki) can be used to automate acceptance tests.

Agile communities consider stories “done” when the acceptance tests (also called story tests) are shown to the customer. Originally, this was a manual process, but in recent years, several frameworks have been created to automate this process, providing acceptance testing all the benefits of automated unit testing. One of the most popular of these if called FIT, created by Ward Cunningham.

By David Hussman

Adopting agile is different for each company, but most companies will go through some amount of change during the adoption of agile.

This session will discuss some of the most common difficulties for adopting agile and provide various plans of attack. The session will start with a listing of issues for the session participants, and some portion of the session will be dedicated to an open forum where the presenter will address the issues collected.

By David Hussman

As with many methodologies, moving agile into an organizations poses larger challenges. Before jumping in, it helps to ask a few questions before "racing toward agility". This session will provide 3 tactical steps that can help your adoption of agile.

There are many factors outside the developer world that can crash all the benefits of agile without regard to its success. This session will provide ways to select agile practices, create a transition plan for adopting agile, and bring people together before trying to adopt new techiniques that are part of agile development. Various tools and techniques will be discussed, and at least part of the session will include Q/A for the presenter to field specific questions about your organization.

By Floyd Marinescu

There are a number of trends occurring that are rapidly changing the way we think about and develop Enterprise Java applications. Trends such as

• Annotations, Dependency Injection, and AOP
• Web 2.0 turning the internet into an application platform
• Domain Driven Design
• SOA
• Open Source in emerging economies
• the rise of scripting languages

... and others are changing the nature of software development in Java.

This talk, presented by author of the book EJB Design Patterns, creator of TheServerSide.com and co-founder/Chief Editor of InfoQ.com Enterprise Software Development Community, will give an update on the most important trends affecting Java that are currently growing and will become mainstream in 1-2 years that you should be paying close attention to.

By Colin Sampaleanu

Spring Framework is the leading full-stack Java/Java EE application framework. Now Spring 2.0 is here, with three attributes which capture what users can expect in this major new release: Simple, Powerful, and Proven.

This session, aimed at developers already familiar with the concepts of Inversion of Control (IoC) and previous versions of Spring, focuses on what Spring 2.0 brings to the table in terms of new capabilities and enhancements.

Examined will be the simpler, more extensible XML configuration mechanisms, which combine with enhanced AOP functionality and integration with AspectJ. Also shown will be the new asynchronous JMS capabilities ("Message Driven POJOs"), container enhancements such as new scoping options for beans and support for scripting languages, and a number of other new or enhanced features.

By Colin Sampaleanu

Spring Web Flow has created a lot of excitement in recent months by bringing the ability to model a "flow" or "conversation" in a declarative fashion, when creating Java web applications.

Traditionally, Java developers working in Web UI frameworks such as Struts, Spring MVC, JSF and others, have been missing a key concept, a scope longer than a single Request, but shorter than a Session. Spring Web Flow introduces the concept of a Flow, which carries state and defines legal page transitions for the duration of a user "conversation" with the web application.

By being able to define flows in a declarative fashion, developers are able to think at a much higher level and eliminate much of the boilerplate code typically involved with controlling page flows and managing state in web applications.

This session is a complete walk through of core Web Flow concepts and capabilities.