By Andrew Glover
In the years since JUnit’s introduction, a number of frameworks have been built to enhance its utility for testing and validating XML, controlling the state of a database, testing legacy code, performance testing, and functional web testing.

Developer testing has arguably become an industry expectation due to the immediate positive affects testing code early has on software quality. It’s no surprise that Java’s JUnit framework has become the de facto standard for developer testing. In the years since JUnit’s introduction, a number of frameworks have been built to enhance its utility for testing and validating XML, controlling the state of a database, testing legacy code, performance testing, and functional web testing. In this session we’ll take a look at XMLUnit for testing XML related code, DbUnit for testing code which depends on a database, JUnit-addons for testing private methods, JUnitPerf for load and performance testing, and JWebUnit for functional web and user acceptance testing. We’ll also examine the extensibility of these frameworks in an effort to combine them into handy aggregate frameworks for performance testing of database code, scenario testing of web sites, and any other combinations we can cook up.

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
Understanding what code coverage represents, how to effectively apply it, and how to avoid its pitfalls will give you an unprecedented understanding of how unit tests may or may not be covering you from sneaky defects.

You’ve drunk the XP cool-aide and made a concerted effort to actively unit test your code. After awhile, however, you may find yourself wondering how good are those tests? Are they actually covering the code adequately? Understanding what code coverage represents, how to effectively apply it, and how to avoid its pitfalls will give you an unprecedented understanding of how those unit tests may or may not be covering you from sneaky defects. We’ll talk code based coverage and specification-based coverage and we’ll look at the tools available to gather these metrics in both the open-source and commercial worlds. Additionally, we’ll examine the notion of mutation testing and its affect on code coverage.

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
Service-oriented architectures (SOAs) are all the rage. But how do you find all of these services once they are deployed? Configuration files are so 90's. Software of the 21st Century should be able to find related services and components without users having to specify particular configurations at start up. The IETF's ZeroConf multicast DNS protocol was designed to solve exactly this problem. JmDNS is Java-based open source implementation of this capability that allows local-link applications to find and use automagically discovered capabilities. Apple's Rendezvous technology is another open-source ZeroConf implementation behind many of the exciting applications it is building for OS X these days. Come learn how you can interact with these or your own service discovery-savvy applications without even having to learn how to spell UDDI. Bring your wireless notebooks to participate in a service-oriented environment (please have a working Java environment as we won't have time to debug installation issues).

Attendees will learn
- Why you don't need UDDI to find services
- The basics of multicast DNS and the ZeroConf protocol
- How to take advantage of Bonjour-enabled devices and software
- How to build their own applications that can be found without a central repository
Rating: Advanced
Category: Client or Server-side Java
Prerequisites: Basic to Intermediate Java skills, basic networking knowledge

By Brian Sletten
Just as the world is feeling comfortable with the Web, Tim Berners-Lee et al inform us that what we have seen so far is just the beginning. His original plans at CERN were larger and grander. The Semantic Web is the new vision of machine-processable documents and metadata to improve search, knowledge discovery and data integration and management. While there are many naysayers chiding such grand visions, there are also pragmatic and useful technologies emerging that can be applied today.

Attendees will learn:

The history and motivations behind the Semantic Web
The technology stack that will make it happen (including RDF and OWL)
An overview of tools and technologies that are beginning to satisfy the vision

This talk stands on its own, but feeds into the "Experiencing the Semantic Web" talk which is more hands on.

Rating: Intermediate
Prerequisites: This is all so new, most engineers will find something to excite them.

By Bruce Tate
O/RM (Object/Relational Mapping) seeks to eliminate repetitive or tedious work enabling the CRUD (create, read, update, delete) that underlies most applications. Hibernate is a popular, open-source O/RM tool that uses reflection (instead of code generation, like EJB, or bytecode injection, like JDO) to manage your persistence layer.

This session will introduce you to Hibernate. After an overview of common usage scenarios, including web and enterprise applications, we'll examine the basics of getting Hibernate running. We'll cover the mapping file format and syntax, including common relational mapping structures. Then, we'll examine the Hibernate API for interacting with the framework. Finally, we'll cover the common architectural decisions you'll have to make as you include this (or any other) O/RM framework.

By Bruce Tate
Agile programming is a collection of core principles and techniques that allow software developers to create lighter, more responsive applications, and to have fun doing it. Many established organizations are either openly or sub-conciously hostile to many of the principles of Agile development.

We'll explore the intersection of these new practices and old-world sensibilities, relying on real-world case studies to illustrate some of the compromises that are necessary to bridge the gap. In addition to technical and process aspects, we'll also spend some time talking about the business aspects, such as how Agile development affects contracts.

By Bruce Tate
In this session, we'll review the new features of Spring 2.0. If you've been using Spring 1.x, you'll want to hear about the improvements.

This material comes directly from Interface21. The SpringFramework version 2.0 brings tremendous maturity to one of the most successful Java projects of our time. In this session, you'll see

- Radical improvements in the simplicity of context definitions
- Much better AspectJ integration
- Unified user interface strategies, and the continued emergence of WebFlow.

By Bruce Tate
This session will help a Java developer choose a persistence framework. After the session, you will
• Understand the core strengths and weaknesses of the main persistence frameworks in the Java space
• Understand where marketing influences can impact persistence
• Know what’s going on behind the scenes to impact the persistence pictures
• Answer questions about persistence frameworks that might not be mainstream


This free-form session is intended to help attendees choose or validate a persistence framework. In it, the instructor will take questions from the audience, and tailor the session to the questions asked. Bruce will focus on three persistence frameworks: EJB, JDO and Hibernate. He’ll talk about the evolution of each of the frameworks. He’ll talk about the fundamental design philosophies of each, and what makes each unique and strong.

But understanding technical strengths is not enough in the area of persistence. To make the best possible choice, a developer or architect must also understand the politics of persistence, and the marketing pressures that lead to the success or failure of each framework. The proposed common standard across JDO and EJB will get special consideration.

This format has been very popular among nofluffjuststuff attendees. It’s highly tailored to each audience, but still flows with good structure. When the session is over, you’ll have a better understanding of the major persistence frameworks in the Java space, and what makes each valuable. You’ll also understand how much of a role market share and technology play in the success or failure of a persistence framework.

By Bruce Tate
The state of the art is progressing rapidly, and dynamic languages are driving the revolution. Find out about these topics that will be central to programming. We'll discuss continuation servers, metaprogramming frameworks and functional langauges.

Seaside provides a much richer web development experience than you can find in Java today. Learn how continuations can radically improve your web development experience, and learn what Java frameworks are doing about it.

The programming world is abuzz over the Rails framework, but how many of the ideas are exclusive to Rails? We'll look at Active Record, and discover the fundamental innovations that let it happen. What improvements might be made by Java persistence frameworks, and where does Active Record come up short?

Concurrent programming will come to a head with the introduction of multiprocessor systems. We'll discover just how broken conventional langauges are. Also, see how functional languages solve this problem.

By Dave Thomas
Are you frustrated by experts who can't tell you what to do, or by junior team members who refuse to see the big picture? How can you best develop careers: both yours and those of your teammates and managers? How can we learn to apply experience more effectively, and why do the many approaches designed to tame complexity actually end up increasing it?

Dave Thomas, of The Pragmatic Programmers, describes the solutions to these and other problems as he turns the Pragmatic Spotlight (and a good dose of twisted humor) on formal learning models, the Nursing profession, and streamlining sheep.

By Dave Thomas
Ruby recently enjoyed its tenth birthday. Instead of cake and candles, the community celebrated by releasing a wave of new libraries and frameworks that make Ruby programming even easier. This talk features some of the best of these, as we explore Ruby.


We'll spend about half the session getting to know Ruby: the syntax, type system, blocks, iterators, and so on. Then we'll dive in and develop some real-world code using web services, RSS, and databases. If you want to come to the Rails talk, and you're not that familiar with Ruby, this talk is a good starting point.

By Dave Thomas
The Ruby on Rails framework has exploded onto the scene over the last few months. Propelled by some genuine benefits, and fueled by a whole lot of controversy, Rails seems here to stay. So, is it a Java killer? (No.) Is it a great way to develop certain classes of web application? (Yes.) Does it really deliver the 10-fold increase in developer productivity that some have claimed? (It depends...)



If you can't help thinking that there must be an easier way of developing web projects, come and join us as we construct an MVC-based Ruby on Rails application using the very latest libraries and tools. You'll get a taste of Ruby, and also a feel for some of the power and productivity gains offered by this remarkable framework. You'll need a grounding in Ruby to get the most from this talk; if you're not already a Ruby developer you might want to attend the Facets of Ruby talk before coming to this one.

By Dave Thomas
The Ruby on Rails framework has unit and functional testing baked right in. In this talk we'll see how easy it is to get started with testing in Rails, and we'll explore jut how deep the testing support goes.

We'll look at the basics: unit testing models and functional testing views and controllers. But we'll dig deeper, looking at the supplied mock objects and seeing how easy it is to add our own. We'll also investigate test fixtures, using them to generate both static and dnamic test data. Finally, we'll have a quick look at performance testing.

By Dave Thomas
Ajax is becoming a requirement for new applications: it creates richer
user experiences and more dynamic applications. However, doing Ajax by
hand is difficult and error prone. The good news is that if you use
Rails, you don't have to do Ajax the hard way.

Rails has built in helpers that support Ajax development,
and comes packaged with the powerful prototype.js and script.aculo.us
libraries.

Come see how Ajax can be made to work with your Rails applications as
we built a very dynamic ToDo list, and see how Ajax can be made robust
with a simple calculator.

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
User interfaces are usually the most turbulent aspect of an application during development. Constant tinkering with the UI means constant changes to your code, so as a UI developer, you want to minimize the scope and effects of those code changes.

Open-source Java provides two powerful software packages that help you manage UI complexity: Tiles and Sitemesh. Tiles composes webpages from discrete regions of your user interface known as tiles. A tile contains a JSP page for layout and one or more JSP pages for content. Sitemesh decorates webpages with decorators that can be associated with URL patterns. Once you set up your decorators, you can decorate pages that match a decorator's URL pattern.

Come see how to use Tiles and Sitemesh with a guided tour from the inventor of Tiles, who has recently become a Sitemesh believer.

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
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
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
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 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 Kirk Knoernschild
Why is software so difficult to change? When you establish your initial vision for the software’s design and architecture, you imagine a system that is easy to modify, extend, and maintain. Unfortunately, as time passes, changes trickle in that exercise your design in unexpected ways. Unlike what you had anticipated, each change begins to resemble nothing more than another hack, until finally the system becomes a tangled web of code that few developers care to venture through. Eventually, modifications to the software intended to improve the system have the opposite affect of breaking other parts of the system. The software is beginning to rot.

The most common cause of rotting software is tightly coupled code with a heavy dependency graph. This session explores the most common symptoms of rotting design, examine their root cause, and present techniques and patterns that have been used on a number of real world projects to help manage dependencies across classes, packages, and the binary units of deployment.

By Kirk Knoernschild
Traditionally, we attempt to make the right architectural decisions early due to the significant anticipated cost affiliated with making incorrect decisions. But this contradicts agile practices which have taught us to embrace change. So how do agile and architecture come together? Conceptually, the goal of agile architecture must be to eliminate the architectural significance of change by crafting software that can easily adapt to change. In practice, developing agile architecture is much more difficult.


Software architecture is organic. The architectural goals you set to achieve early in the development effort differ from those you'll need to satisfy later. Change occurring throughout the software development lifecycle impacts architecture. The ability to accommodate shifts in architecture is directly related to the dependencies between software modules. In this session, we examine patterns and principles that lead to agile architecture. Extensive discussion is devoted to modularizing units of deployment, and how code can be created and organized to create more flexible, reusable, maintainable, extensible, and testable software components. Topics of discussion range from coupling between classes to the dependency structure between your modules of deployment. Examples gleaned from real world J2EE development effort will be used in a pragmatic case study that examines the evolution of a system from its initial deployment through a number of refactorings that positively influenced the architectural resiliency of the final product.allow you to apply many of these concepts immediately.

By Ramnivas Laddad
A lot is happening in the field of Aspect-oriented programming (AOP). AspectJ and AspectWerkz, the two leading AOP implementations, have merged, bringing in their respective strengths. The merged version, AspectJ 5, adds many new features aimed at simplifying writing and deploying aspects. The new features include an annotation-based and XML-based syntax to define aspects, support for new Java 5 concepts, and load-time weaving. The tools support for AOP continues to improve, as well. Further, the most popular IOC framework, Spring, enables integrating aspects written in AspectJ. There is also serious discussion and preliminary work going on to support AOP right into the VM itself. All in all, there is a lot to learn about the changes in the exciting field of AOP. This session is designed to help you get up to date with all these changes.

This session provides a guided tour of the new things in the AOP world. It explains new features in AspectJ along with the practical considerations in utilizing each of them. The presentation explores the fundamental synergy between AOP and metadata to understand right (and wrong) utilization of metadata-based crosscutting. Load-time weaving (LTW) enables adding aspects to your existing applications deployed in any application server with a minimal effort. The presentation shows how to utilize LTW to improve your productivity considerably, even if you don't yet subscribe to the AOP philosophy and don't want to use AOP in production. The presentation also demos the latest AspectJ Development Tool (AJDT) in Eclipse (that has improved a lot) to make Java developers feel home when developing with aspects. The presentation includes many demos to reinforce the concepts learned, as well as give a feel for what it would be like to apply aspects written using new features.

This session is particularly targeted at developers with good familiarity with AOP concepts and the AspectJ language. It is recommended to attend the “Introduction to Aspect-oriented programming with AspectJ” session or read articles and/or books that introduce AOP and AspectJ to obtain the prerequisite.

By Ramnivas Laddad
Aspect-oriented programming (AOP) promises to modularize crosscutting concerns. Like all new technologies, AOP has its share of over zealousness and unjustified criticism, neither of which is useful to developers deciding if they should use AOP in their applications. Attend this talk to understand the real deal behind AOP and change your perspective of AOP forever.

This talk goes beyond myths surrounding AOP and shows the real deal. It examines many practical applications implemented with and without aspects, providing a context for scrutinizing AOP. It also discusses ways to adopt AOP in pragmatic, risk-managed ways allowing developers to try AOP in their own system and gain understanding at the experiential level without exposing them to undue risk.

This session is aimed at developers who have some understanding of AOP, perhaps even considering using it in their system, but have some lingering concerns about its practicality. After attending the session, you will have a clear picture of AOP and be ready to make a studied decision about it.

By Ramnivas Laddad
Support for aspect-oriented programming is an important part of the Spring framework. It is the AOP support that allows keeping implementation of functionality such as transaction management and security out of your POJOs. While many developers only use aspects provided with Spring, once you understand how it all works, you can make a better use of those aspects, extend them, and write brand new aspects.

This session focuses on Spring AOP implementation. We cover topics such as Advice, Pointcuts, Advisors, proxy configuration, proxy factory bean, the autoproxy mechanisms, and the introduction mechanism. We will also examine many aspects shipped with the framework itself. While Spring’s AOP solution is sufficient in a typical enterprise application, there are situations where we need more full-fledged AOP support. Therefore, we will discuss using AspectJ with Spring and how to leverage the dependency injection mechanism with AspectJ aspects.

This session is targeted for enterprise application developers who want to gain in-depth understanding of Spring's AOP feature. After attending this session you will gain a solid understanding of Spring AOP, standard aspects shipped with the framework itself, and how to write new aspects. Some familiarity with the Spring framework, gained by attending other Spring talks or reading about Spring, is recommended.

By Ramnivas Laddad
Enterprise application development is a gold mine for applications of AOP. There are many crosscutting concerns found in a typical enterprise application, ranging from well-known security and transaction management to application- and technology-specific concerns. Using AOP leads to implementations that are easy to understand and easy to change.

This session shows how to address common problems faced by typical enterprise applications, with a focus on web applications using AOP. It will present examples of applying aspects to persistence, business, and web layer. It will show how to apply aspects synergistically with technologies such as Hibernate, JAAS, JMX and Spring. Many of the examples include reusable portions enabling them to be readily used in your own application.

This session is targeted at developers with familiarity with AOP and enterprise applications. It is recommended to attend the “Introduction to AOP with AspectJ” session or read articles and/or books that introduce AOP and AspectJ prior to attending this session.

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
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
How do you get started with an Agile development methodology? Everyone has been talking about eXtreme Programming for years, but how do you get it introduced to your team? Many times, you're not simply transitioning from from one methodology to another -- you're introducing a methodology for the first time. Adding structure to a previously unstructured endeavor. Adding a touch of discipline where programmers once roamed free.

This presentation talks about how to introduce Agile practices slowly. Think of it as refactoring your team iteratively. If you drop 25 new "best practices" on developers all at once, the chances of getting any of them to stick is slim. If you start with one practice and get buy-in on it, sneaking in the next one (especially if it is complementary) is far easier.

• starting with source control
• easing into iterations with XPlanner
• is your team ready for pair programming?
• writing your first unit tests
• evaluating your code base for unit test coverage

By Scott Delap
This session will introduce attendees to the various options and problems that exist with deployment of a Java UI application written in Swing or SWT. Topics covered will include obfuscation of classes in preparation of deployment, open source installers, and Java Webstart.


Common Issues with Java Deployment
Obfuscation
Installers
Java Webstart
Obfuscation
Open Source Obfuscation Solutions
Issues and ways around them
Installers
Creating and Executable Jar
Creating an Installer Using Open Source
Java Webstart
Webstart Deployment Options
Pack2000

By Scott Delap
Rich client application development using Java can be intimidating giving the vast flexibility in application design and structure. It also can be frustrating to create the large number of support services (persistence, menus, event and job frameworks) that a large scale rich client applications needs. The Eclipse Rich Client Platform is one project attempting to solve these issues by providing a core infrastructure that not only provides the day to day services a rich client application developer needs, but also providing a suggested path to guide you down the road of designing your application. This presentation introduces both the Eclipse RCP and the tools provided by the Eclipse IDE that assist developers in writing RCP apps.


Rich client application development using Java can be intimidating giving the vast flexibility in application design and structure. It also can be frustrating to create the large number of support services (persistence, menus, event and job frameworks) that a large scale rich client applications needs. The Eclipse Rich Client Platform is one project attempting to solve these issues by providing a core infrastructure that not only provides the day to day services a rich client application developer needs, but also providing a suggested path to guide you down the road of designing your application. This presentation introduces both the Eclipse RCP and the tools provided by the Eclipse IDE that assist developers in writing RCP apps.

How can a RCP Framework help my application?
Menus
Events
Jobs
etc..
Introducing Eclipse RCP
The base of the Eclipse IDE
Actively Developed
Leveraged By Many Projects
...
Eclipse RCP Services
Plugins
Core based on OSGi
Extensions
Menus/Toolbars/Actions
Jobs
View Framework
Tools Support
Plugin Editors
Product Definition
...
Deployment
One Click Webstart Deployment
Support Multiple Platforms

By Scott Delap
Too often, Swing applications are slow, ugly, and hard-to-maintain. It turns out that it doesn't have to be this way. Swing can be used to create highly-responsive, beautiful applications that are very maintainable. If this isn't consistent with your own experience, don't feel bad; its not very obvious how to make Swing sing.



In this session, I explore three topics that lead to much better Swing applications:

- Proper Swing threading
- High-quality third-party Swing look-and-feels
- Good practices for coding Swing applications

In the threading portion of the session, I explain Swing's event handling architecture and its implications for Swing applications. Understanding this topic is crucial to creating highly-responsive Swing apps. I demonstrate how to use this knowledge in the form of many live-coded examples, and I show how frameworks like SwingWorker and FoxTrot can make this easier. Java's default look-and-feel, Metal, is awful (and in my opinion, the "Ocean" theme in JDK 5.0 doesn't do enough to improve it); you should stop using it immediately. But creating good-looking applications is sadly more than slapping in a look-and-feel; you must also take care to understand the principles behind attractive layouts. I spend the second part of this session exploring how to make your Swing applications look great through a combination of third-party look-and-feels and layout techniques.

By Scott Delap
Today's users are beginning to demand richer and richer application experiences. Plain html pages simply don't cut it anymore. Applications like Google Maps (Ajax) and Yahoo Maps (Flash) show how the UI experience can be pushed to the next level. As an IT manager, how do you decide which route to take however? Should you use Ajax because it is the new "it" technology. Is Flash a viable option with its 95%+ browser availability? Perhaps Java deployed through web start is really the best choice in contrast to what the buzz would lead you to believe. This presentation takes a look at these three core rich client technologies from both deployment/user experience and ease of development perspectives.

Today's users are beginning to demand richer and richer application experiences. Plain html pages simply don't cut it anymore. Applications like Google Maps (Ajax) and Yahoo Maps (Flash) show how the UI experience can be pushed to the next level. As an IT manager, how do you decide which route to take however? Should you use Ajax because it is the new "it" technology. Is Flash a viable option with its 95%+ browser availability? Perhaps Java deployed through web start is really the best choice in contrast to what the buzz would lead you to believe. This presentation takes a look at these three core rich client technologies from both deployment/user experience and ease of development perspectives.

Meet the Players
Java
Swing
Swt
Example Apps
Ajax
Ajax 101
Example Apps
Flash
Flash 2006
Laszlo
Flex
Example Apps
User Experience
Java
Ajax
Browser Issues
Back/Forward
Hyperlinks
Flash
Deployment
Java
Web Start
Ajax
Cross Browser Issues
Flash
Development
Java
Tool Support
Http Invocation
UI Libraries
Swing
Swt
Ajax
XMLHttpRequest
XML
DOM's
Javascript
Can Struts Developer's Get This?
Flash
Laszlo
Flex
Playing Nice in the Browser
Conclusions
Applications that Work Well with Java
Applications that Work Well with Ajax
Applications that Work Well with Flash

By Stuart Halloway
Dependency Injection (DI) is the cornerstone of Spring. The core concept is quite simple, but (surprise!) actual practice can become complex. To take full advantage of Spring DI, you need to understand not only the basics on configuration, but also the container lifecycle model and the various hooks provided by the framework.

Topics will include

• The difference between DI and Continuous Integration


• Setter Injection


• Constructor Injection


• Factory Injection


• Bean lifecycle


• Method Injection


• Using the ApplicationContext


• Custom PropertyEditors

By Stuart Halloway
Hibernate is easy to get started with, but can sometimes be hard to make efficient or secure. In fact, the default settings for Hibernate createapplications that will run slowly, cause unwanted round trips to the database, and may be more restrictive and/or permissive from a security standpointthan you would otherwise want.



This session will show advanced techniques for tuning performance, including:
• advanced collection mapping strategies
• lazy loading
• cascading update management
• lifecycle management
• Hibernate's interceptor layer
In addition, we'll examine the security considerations when using Hibernate. Often, single-credential data access isn't enough for sensitive data. We'll
walk through using per-user credentials for data access, logging security information about and through Hibernate, and accessing data sources through secure application servers.

By Stuart Halloway
Java has always provided a model for concurrency and threads. With Java 1.5, this model received a major facelift. Learn how to use the new concurrency utilities to build responsive, scalable, and correct concurrent applications.


Java's support for threads is broad and deep. From the early days of the platform, programmers have used threads, synchronized blocks, and monitors to build safe multi-threaded applications. Java 1.5's new concurrency utilities greatly reduce the need to use these primitives directly. Now, Java provides a set of lock classes and task scheduling tools that provide much more leverage in writing real applications. We'll explore java.util.concurrent, and also see how the Java Memory Model has been corrected in 1.5.

Most of the advantages of java.util.concurrent can also be had in previous version of Java. We