By Ben Galbraith
It sounded like such a good idea back in the mid-nineties: based the Java platform on a standards-based, open community, and let anyone participate. There is no question that Sun's strategy for Java's stewardship via the JCP and sponsored open-source has yielded some enormous benefits. However, these have not been enjoyed without tremendous cost.

Perhaps the recent pop-culture book The Paradox of Choice put it best: "When people have no choice, life is almost unbearable. As the number of available choices increases, [as it has in the Java community], the autonomy, control, and liberation this variety brings are powerful and positive. But as the number of choices keeps growing, negative aspects of having a multitude of options begin to appear. as the number of choices grows further, the negatives escalate until we become overloaded. At this point, choice no longer liberates, but debilitates. It might even be said to tyrannize."

Does this ring true in your environment? Are you tired of spending countless hours evaluating IDEs, build systems, app server vendors, competing web frameworks, competing persistence standards, competing vendor implementations of those standards, and so forth? You're not alone.

The mess of competing standards, implementations, and other overlapping non-standard frameworks in Java, and lack of a single authoritative vendor-guide (i.e., Sun's "guidance" has proved irrelevant and unproductive) kills Java's productivity for all but a handful of experts with the experience to navigate the landscape.

This session details the ideas and experiences of one enterprise that has set out to solve this problem.
The topics reviewed will consists of:

- Defining a standard "stack" of Java frameworks and technologies, but also "standardizing on demand"

- Creating a template application that acts as the starting point for any new project

- Approaching reuse retrospectively, not prospectively

- Unifying training and support, and providing organization mentoring

- Simple project health monitoring

Of course, the idea of standardizing application development in an organization is nothing new. You may have tried it. Did it work? Being successful at this endeavor is tricky, and most efforts fail.

While the specific example detailed in this session is still underway and its too early to declare unqualified success, come learn about this effort and how its principles can be applied in your organization.

By Ben Galbraith
For many of us, XML has become a ubiquitous presence in application development, whether parsing, validating, or manipulating it. For many of us, all
that XML is coupled with pain, in the form of tedious APIs (like, say, the W3C DOM API) and confusing technologies (oh, I don't know, W3C XML
Schema?).

In this session, I share the following tips for making the XML in our lives a little easier to deal with:
- Use StAX instead of SAX
- Use StAX to create XML
- Use JDOM instead of W3C DOM
- Use XPath to select XML
- Use Jaxen to enable XPath over custom trees
- Use RELAX NG instead of DTD or WXS
- Use Trang when DTD/WXS output is required
- Use Sun's RELAX NG Converter when WXS input is required
- Consider RELAX NG's compact syntax
- Use Schematron to extend schema languages
- Consider XML namespaces for versioning
- Ignore unknown namespaces

By Ben Galbraith
You can do some pretty cool things with XML these days (despite what some curmudgeons in the technology world may claim). In the past few years,
XML has solidified its place as the lingua franca of data sharing and data manipulation. But XML as a data transfer language is only marginally
interesting. Things get really exciting when XML is dynamically transformed into other formats.
In this session, I focus on two XML formats which can be readily transformed into high-quality presentation-centric output formats. XSL-FO is a
typesetting format for XML that can be readily converted into PDF (or Postscript and some other formats). SVG is a vector graphics language in XML --
a sort of open-source version of the popular Macromedia Flash format. SVG files can be converted into beautiful, completely scalable -- and interactive -
- images.

You can do some pretty cool things with XML these days (despite what some curmudgeons in the technology world may claim). In the past few years,
XML has solidified its place as the lingua franca of data sharing and data manipulation. But XML as a data transfer language is only marginally
interesting. Things get really exciting when XML is dynamically transformed into other formats.
In this session, I focus on two XML formats which can be readily transformed into high-quality presentation-centric output formats. XSL-FO is a
typesetting format for XML that can be readily converted into PDF (or Postscript and some other formats). SVG is a vector graphics language in XML --
a sort of open-source version of the popular Macromedia Flash format. SVG files can be converted into beautiful, completely scalable -- and interactive -
- images.

By Ben Galbraith
Ajax -- called DHTML just a few months ago -- has revolutionized (or "radically iterated", if you like) web application development in the short few months since the term was coined.

What is it all about? Why are we excited about a set of capabilites that have been sitting in our browser for years? What can you do with it? And, how can you do it?

Ajax, short for Asynchronous JavaScript and XML, is a technique for communicating with servers from within a web page without causing a page refresh.

This session provides an introduction to Ajax and an orientation to the state of the ajaxian universe. The basic ajaxian techniques will be demonstrated through live coding, and more advanced examples of Ajax will be demonstrated and deconstructed.

Attendees will understand how the Google Maps UI is built (and why it isn't as hard as it looks), how Ajax can improve portals, community sites, and pretty much any other type of web application.

Furthermore, the issues surrounding how to create an Ajax application that doesn't turn into an unmaintainable pile of hacked up crap JavaScript will be discussed.

At the end of the session, an off-line capable, web services consuming Ajax RSS aggregator will also be demonstrated.

This talk will be presented by one or more of the founders of Ajaxian.com.

The session "Ajaxian JavaScript Frameworks" complements this session, and dives deeper into specifics on how to use many of the frameworks introduced in this session.

By Ben Galbraith
In the "Introduction to Ajax" session, we discuss what Ajax is, how it works, and how others are using it.

This session goes deeper into Ajax by reviewing the existing JavaScript frameworks that aim to make it easier.

The scope of the frameworks is all over the made, from unit testing JavaScript to deconstructing other websites to making it easier to create your own ajaxian effects.

If you want to easily add some Ajax to your site, come to this talk, presented by one or more of the founders of Ajaxian.com.

By Ben Galbraith
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 Ben Galbraith
Are you spending more time plumbing your Swing applications than solving business problems? Has your Swing application grown out of control? This session is for you.

In the first part of the presentation, I analyze the architectural problems that plague many Swing applications and present architectures that overcome these problems. These architectures are presented in terms of principles along with a reference implementation. You can therefore either adapt the principles to meet the needs of your existing applications, or incorporate the specific ideas of the reference implementation into your new projects. Fortunately, there are some existing frameworks that have done some of the architectural work already. I present some of these frameworks in the rest of the presentation.

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
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
Pop quiz: which is faster, Java or C++? If you are talking about allocation performance, the answer is Java, hands-down.

The performance of the garbage collector in the HotSpot JVM has improved steadily since JDK 1.0. The early garbage collectors were criticized for poor performance, but, except for some edge cases, garbage collection performance in HotSpot is now so good that allocation is an area where Java programs handily outperform comparable C++ programs.

The early JVMs used a simple mark-sweep collector, which was easy to implement and worked well enough for short-lived, small-heap applications. Current JVMs use a generational garbage collection approach, using different collection strategies for different areas of the heap, which for typical applications, offers excellent throughput and short pauses. Additionally, HotSpot versions 1.4.1 and later offer several alternate collectors for multiprocessor and large-heap systems.

In this session, we’ll explore the basic approaches to garbage collection, garbage collection options in the the HotSpot JVM, some common garbage collector tuning options, and some idioms to avoid in order to make your application coexist peacefully with the garbage collector.

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 Bruce Tate
This session, for the Spring beginner, helps you:
• Understand dependency injection and inversion of control
• Know the meaning of lightweight containers and Spring
• Understand the basic pieces of Spring
• See core Spring modules in action, including Persistence, AOP, transactions.

Attendees need not know anything about Spring. This session does talk about integration with core J2EE frameworks like JDBC and transactions.

The Spring framework is one of the fastest growing open source frameworks. New job postings are gaining rapidly, and many customers are adopting Spring instead of heavier alternatives. In this session, we’ll introduce Spring. You’ll see how Spring can give you much of the power of EJB, without the complexity or pain.

Spring uses concepts like dependency injection and aspect oriented programming to ease standard enterprise development. Spring developers write plain, ordinary Java objects (POJOs), instead of sophisticated components. In this session, you’ll see a basic Spring application. You’ll also see some details about some of the enterprise integration strategies, including:

• Spring AOP
• Transactions
• Persistence
• Model/view/controller

When the session is over, you won’t be an expert, but you should have a much clearer understanding of what Spring does, what it doesn’t do, and why it’s growing so rapidly.

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
All programming languages have a limited life span, and Java is no different. This is a philosophical session rather than a programming session. Sooner or later, Java will lose its leadership position. This session will explore Java's strengths and weaknesses. We'll try to understand whether conditions are ripe for alternatives to emerge, and what those alternatives may be.

The Java programming language has been tremendously successful. Many of the roots of its success may be surprising to the audience. But every major programming language has a limited life cycle. While it’s true that Java and .NET seem to be the only games in town, some alternatives are beginning to emerge.

In this session, we’ll discuss some of the limitations of the Java language, and the impact that they might have on the productivity of Java developers. We’ll then look at some of the innovations around other frameworks and languages, and some of the features of those languages that boost the productivity of other non-Java developers:

• Typing, and why it matters
• Code blocks and closures
• Regular expressions
• Innovative frameworks

Finally, we’ll take a look at where developers may look at using other languages. Clearly, most of the work that we do will be in Java for the foreseeable future, but certain project classifications may make it much easier to embrace alternatives, for good competitive effect.

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 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 David Geary
Okay, so you know a little about JSF. You understand managed beans, action outcomes and how to attach standard JSF validators to components in a JSP page.

But there is a great deal of functionality that the average web application supports that JSF doesn't provide out of the box. For example, wouldn't you like to have JSF automatically place asteriks in front of labels for required fields? You are going to implement client-side validation, which JSF does not support out of the box, aren't you? Of course, you're going to test your application, right? And don't forget to trap unauthorized use of the back button.

How do you do all of that stuff in a JSF application? If those are the kinds of questions that keep you up at night, then this session is for you. We will explore the outer reaches of JSF development to illustrate how you can bend your next JSF application to your will.

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 Jason Hunter
Java's new Metadata facility introduced in J2SE 5.0 defines a way to attach decorations to classes, fields, methods, and even packages that can be extracted by the compiler or runtime tools to provide advanced functionality. Think of metadata as an extended @deprecated flag, or think of XDoclet++. In this tutorial session you'll learn how Metadata fits in the Java platform (and how it compares to the C# platform). We'll cover how to use the metadata attributes provided in the core J2SE libraries and how to write your own. We'll also show a bit of what's coming in JSR-181, tasked to define standard metadata attributes for web services.

Attendees should be skilled Java programmers ready to see what's possible in the latest release and learn to make the most of it.

By Jason Hunter
Web Caching is very important for high traffic, high performance web site but few people know all the professional-level strategies. In this talk I'll share some of the tricks of the trade, including advanced tips from Yahoo's Mike Radwin.

We'll start with the basics: using client-side caches, conditional get, and proxies. Then we'll talk about more advanced features: how best to handle personalized content, setting up an image caching server, using a cookie-free domain for static content, and using randomization in URLs for accurate hit metering or sensitive content.

Attendees should have experience or interest in how the web works and in cajoling the web into doing their bidding.

By Jason Hunter
XQuery is a new language from the W3C that lets you query and manipulate XML -- or anything that can be represented as XML, such as relational databases. As a Java developer -- especially a server-side Java developer -- XQuery is key to searching and manipulating large XML repositories or performing any XML-centric task.

This talk introduces XQuery. I'll explain the XQuery language; I'll show how to call XQuery from Java; and as the creator of JDOM, I'll also explain when to use XQuery instead of JDOM, and when to use both.


Attendees should have an interest or need in managing large sets of XML, but need not have any past experience with XQuery. After the session, attendees will be able to program XQuery and know which implementations to trust.

By Jason Hunter
The new Java 5 release introduces a number of significant Java language enhancements: generics, typesafe enums, autoboxing, an enhanced "for" loop, a static import facility, and a general-purpose metadata facility. This talk gives an overview of the changes and helps you understand what all the funny new syntax means.

The main new language topics covered:

* Generics, also called "parameterized types", which let you specify the type of objects used in a collection, among many other things.

* Autoboxing, that lets you implicitly convert from primitives to reference types, and vice-versa.

* An Enhanced For Loop, that lets you iterate over arrays or collections with half the code as before.

* Typesafe Enums, to create object-oriented, extensible enumerated values.

* Static Imports, to put into scope static methods and fields.

* Varargs, that allows methods to accept an arbitrary number of parameters.

* A Metadata Facility, allowing decoration to classes and methods for later tool consumption. Covered in more depth in the "Java Metadata" talk.

* Random new Library Features, like the ability to control external process launching, output formatting, and input scanning.

This talk describes the proposed changes and shows how they work together to improve the Java language. We also take breaks to see how closely Java matches the C# designs!

Attendees are assumed to be competent Java programmers.

By Jason Hunter
There are many interesting and useful algorithms that people just don't remember or never learned. The Boyer-Moore string search algorithm is one prime example. The randomized skip list is another. Both solve common problems with wonderful flair and finesse -- and performance-wise
they blow the pants off brute force solutions. This session covers these two algorithms plus several others. It's like your college algorithms course but with a practical bent and absolutely zero proofs. Extra bonus: The Google PageRank algorithm.


This session covers these two algorithms plus several others. It's like your college algorithms course but with a practical bent and absolutely zero proofs. Extra bonus: The Google PageRank algorithm.

By Matt Raible
One of the hardest parts about J2EE development is getting
started. There is an immense amount of open source tools for web app development. Making a decision on which technologies
to use can be tough--actually beginning to use them can be even more difficult.

Once you've decided to use Struts and Hibernate, how do you go about implementing them? If you look on the Hibernate site or the Struts site, you'll probably have a hard time
finding any information on integrating the two. What if you want to throw Spring into the mix? For developers, one of the best ways to learn is by viewing sample apps and tutorials that explain how to extend those applications. In order to learn (and remember) how to integrate open source technologies such as Hibernate, Spring, Struts, and Ant/XDoclet, Raible created AppFuse.



The beauty of AppFuse is you can actually get started with
Hibernate, Spring, and Struts without even knowing much about them. Using test-driven development, AppFuse and its
tutorials will show you how to develop a J2EE web application quickly and efficiently.

By Matt Raible
In this session, you will learn what Ajax is and how it is
revolutionizing the way thatweb applications are developed.
In a similar way, the Spring Frameworks is greatly simplifying the code that we write Java web applications with.



Combining Ajax and Spring can not only make you more productive, but can also greatly enhance your user's experience with your application. This session will show you how to combine the two technologies, as well as provide several tips and tricks to simplify Ajax development.

By Matt Raible
Aspect-Oriented Programming is a great way to implement
cross-cutting concerns (i.e. caching,logging, security, transactions) into your applications. Transactions are an essential piece in enterprise applications for ensuring data integrity. This session covers two topics: Spring's AOP and Transactions Framework.

In the first half, you will learn about AOP and how Spring's API helps you implement interceptors to reduce code duplication in your applications. In the second half, you will learn about Spring's Transaction Framework and how it compares to J2EE's API.

By Neal Ford
Is Service Oriented Architecture the next wave of distributed computing or just the same old crap in a shiny new package? This session provides an overview of what most people agree is the definition of SOA. I talk about SOA, ESB, CORBA, your MOM, and a bunch of other acronyms.

This session is a pragmatic look at SOA from a developer perspective, including such (never talked about) topics like tranports, granularity, versioning services, transformations, and whether you should be doing this or not. I show lots of slides with diagrams and talk about how to evolve towards an SOA. SOA can work if you ignore the hype and focus on the real meat: building loosely coupled message-based applications. This session discusses just that.

By Neal Ford
Regular expressions should be an integral part of every developer?s toolbox, but most don?t realize what an important topic it is. Regular expressions have existed for decades, but many developers don't understand how to take full advantage of this powerful mechanism, either through command line tools and editors or in their development.

This session shows how to fully exploit regular expressions. It begins with the basic premise of how regular expressions work, then shows how to take advantage of the RegEx library built into the Java platform. This session shows how to use wildcards, escape characters, meta-tags, character class operators, look-aheads/look-behinds, and how to use the greedy operators effectively. It covers regular expressions from the beginning through to advanced usage, both in Java and in tools that support regular expressions. This session is packed with real examples of regular expressions (including a game show with no fabulous prizes).

Key Session Points:

Common Regex mistakes

By Neal Ford
This session discusses techniques and tools for debugging enterprise applications (without using System.out.println()!)

It's an interesting dilemma – we have the best tools for software development ever, yet developers are still debugging enterprise applications using ystem.out.println()! This session discusses techniques and tools for debugging enterprise applications. It shows how to perform remote debugging through all the major IDEs, either on the same machine or across a network. It also shows how to debug using the command-line jdb debugger (the only one guaranteed to always be available).This session shows how to debug web, EJB, and lightweight enterprise applications. It discusses class loaders, interactive enterprise debugging with Groovy, and how to automate repetitive tasks using JWebUnit and Selenium, making the computer do work for you instead of vice versa (how many times do you have to walk multiple pages through a web application to get to the point where you can debug it?). This session shows you how to automate these and other common debugging tasks. The goal is to make hunting and eliminating bugs in complex applications much easier.

Key Session Points:
• Setting up remote debugging in IDE's
   o Eclipse
   o IntelliJ
• Effective remote debugging
• When it's all you've got: jdb and enterprise applications
• Forensic debugging using loggers
• Debugging web applications
   o Inspector
   o Bookmarklets
• Debugging EJB
• Debugging in lightweight frameworks
• Interactive Debugging with Groovy
• Automating debugging tasks
   o JWebUnit
   o Selenium

By Neal Ford
This session shows how to use Java as the building block for domain-specific languages. It discusses the next revolution in programming: language-oriented programming and the nascent tools that support it.

If you look at the way advanced programmers in highly dynamic languages (like Lisp, Smalltalk, Ruby, etc.) work, they tend to build domain specific languages on top of their low-level language. The language syntax itself becomes building blocks for languages that are highly specific to their problem domain. It’s not as easy to apply this technique to a static language (like Java), but it is possible. This session shows how to use Java as the building block for domain-specific languages. It discusses internal and external DSLs, with pros and cons for each. This session progresses from creating an internal DSL using Java syntactic elements as keywords through using compiler-building tools to create your own external DSL arriving ultimately at the new tools that allow you to build, edit, and deploy external DSL (language workbenches). This session covers the theory and practice of building DSL's and why this is an important step in the evolution of programming paradigm.


Key Session Points:
1. Why Dynamic languages?
2. Building domain languages
3. Language-oriented Programming
   a. Internal DSLs
   b. External DSLs
4. Internal DSL
   a. Characteristics
   b. Advantages
   c. Disadvantages
5. External DSL
   a. Characteristics
   b. Advantages
   c. Disadvantages
6. Case Study: Building your own language
   a. Building the parser
   b. Building the lexer
   c. Abstract Syntax Trees
7. Parsing other languages
   a. Parsing Java
   b. Parsing HTML, JavaScript, and others
8. Language Workbenches

By Nick Lesiecki
Design patterns have long been part of the experienced developer's tool chest. However, design patterns can affect multiple classes and this makes them invasive and hard to (re)use. This presentation will discuss how AOP solves this problem by fundamentally transforming pattern implementation. The class will examine examples of various traditional design patterns (including some of the famous GoF patterns) and discuss the practical and design benefits of implementing them with aspect-oriented techniques. This session will be of interest to anyone who has struggled with design patterns. It is also the perfect session for a programmer interested non-trivial applications of AOP, or who wishes to see aspect-oriented design in action.





Goals/Key Points:

• Review design patterns: what they are, how they can be thought of
  
• How AOP can affect pattern implementation
  
• Review AOP key concepts and AspectJ syntax
  
• The Decorator Pattern, in Java, then AspectJ
  
• Apply more advanced AOP to the Swing Thread Safety patter
  
• How to reuse open source pattern implementations (Observer)
  

By Nick Lesiecki
Aspect Oriented Programming offers enhanced modularity and cleaner separation of crosscutting concerns. That's all fine and well for architecture geeks. But can it help your project today? Has anyone applied it in the real world? The answer is "yes," and in this session, an AOP expert and early adopter will demonstrate how his team used aspect oriented programming to implement non-trivial business concerns. Along the way attendees will learn about advantages of AOP and understand some of the problems encountered adopting it.

This session will give an overview of how the Adbase team at VMS (http://vmsinfo.com) brought AspectJ into a J2EE data integration project. It will start with showing how aspects provided a clean way to debug errors in a third party library. A more complex example will illustrate how AOP helped dynamically update shopping cart prices without requiring extensive modifications to the domain objects. Finally, the class will cover one of the first reusable aspects developed by the company—an aspect to manage relationships between persistent objects. The last part of the presentation will examine the challenges of and tactics for AOP adoption. Attendees will learn what compromises were necessary, how the team scaled the learning curve, and which development practices helped ease adoption and mitigate risk.

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
In this presentation, we'll explore the top four mapping sites and show you how to take advantage of their free services. MapQuest, Yahoo Maps, Google Maps, and MSN Virtual Earth all bring slightly different capabilities to the table. These sites allow you to create your own interactive maps with minimum effort and no previous mapping experience. They take care of hosting the mapping data and making it easy to manipulate -- all you have to do is bring a little bit of know-how to the party.

Thanks largely to Google, web mapping is experiencing a renaissance. Google's mission statement is, "... to organize the world's information and make it universally accessible and useful". They aren't specifically talking about web mapping, but the sentiment certainly applies. If you have data that naturally has a geographic element (a customer list with addresses, sales reports by regions, even a collection of favorite restaurants), today's websites make it easier than ever to display them on a map.

Even if you aren't specifically interested in creating your own maps, this presentation gives real-world examples of many industry hot-button topics -- SOAP vs. RESTful web services, JavaScript and AJAX, and a clear distinction between first generation web technology (Web 1.0) and what the pundits are calling "Web 2.0".

By Stuart Halloway
JUnit is great. Jython and JRuby are even better. Unit testing libraries look the same everywhere, so why not use the one that lets you get your job done faster?

Unit testing has taken the world by storm. Almost every major language has a JUnit-like library. And here's the good news: These libraries are so similar that once you learn one, you can use any of them.

Given that many languages interoperate directly with Java, you aren't limited to JUnit. You can pick the library that provides the best language level support for writing concise, easily maintainable unit tests. Circa late 2005, there are good arguments for the unittest module in Jython, and Test::Unit in JRuby.

The talk is divided into three parts:

1. A crash introduction to unit testing Java code. We'll cover test-driven development, test cases, assertions, fixtures, and test suites. We'll be using Jython and JRuby but the concepts are exactly the same in any language


2. A look at the Python and Ruby features that make Jython and JRuby compelling choices. We'll see how tests are faster to develop and easier to maintain than JUnit tests. And perhaps surprisingly, we'll also see how tests scale better when applications get large.


3. A candid comparison of Jython, JRuby, and JUnit, including advantages and disadvantages of each. One size does not fit all.

By Stuart Halloway
For centuries people have used crypto to build (and break) secure systems. Computers have only raised the pitch of conflict, providing enormous cryptographic power at commodity prices. Most programmers do not write their own crypto libraries, instead relying on the services of an operating system or virtual machine. But even with all this support, building secure systems is a daunting task.

This talk will cover three things all programmers need to know:
1. the basic tools of computer crypto
2. the programmatic APIs to these tools
3. common programming mistakes that can undermine otherwise secure systems
You will learn the basics of hashing, message digests, public key encryption, symmetric key encryption, certificates, and key management. With each, you will see programmatic examples, with advice for correct usage.

By Stuart Halloway
The Java platform is built from the ground up with security in mind. This talk will introduce the security features of the J2SE, building quickly from the basic classes to realistic examples.

You will learn the core APIs:

SecurityManager, AccessController, Permissions and Policy

JAAS Subjects, Principals, and LoginModules

You will then see how to invoke these APIs in real application scenarios. You will learn how to:

Partition your applications to safely invoke downloaded code

Read and write Java policy files

Extend the architecture with custom permissions

Provide secure services through PrivilegedActions

Use JAAS to authenticate and authorize users

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