By Neal Ford

There's the perfect world, and then there's the world you have to live in. Lots of organizations would like to reap the benefits of Agile development techniques but don't know how to get started. This session discusses the key benefits you can derive from Agile software development so that you can decide for yourself how many agile techniques will work within your organization.

I discuss project planning and estimation, how to benefit from pair programming when you aren't allowed to pair, how to measure your progress, and other project milestones. Agile software development isn't just an unrelated set of activities, it is a discipline. Once you understand the component parts of the discipline, you can apply them to your less-than-agile world.

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

What does code + methodology have to do with one another? Everything! Agile projects focus on delivering working code, and tools exist to allow you to verify some quality metrics for your code. This session is a survey of tools and metrics that allow you to determine the quality of your code and strategies to "wire it" into your agile project.

Agile projects focus on delivering code. The responsibility for the quality of that code lies with developers. Yet most developers have a poor sense of how to gauge the quality of code, both during development and forensically. This talk lives on the boundary between what is important in agile projects and ways to verify code quality. It is both a survey of tools and metrics and strategies for proactively applying these techniques to ongoing projects. I talk about the Hawthorne effect, analysis tools (both byte and source code), useful metrics, tools for generating metrics, and how to analyze raw data into actionable tasks.

Session Topics:

• The Hawthorne Effect
• How Agility and Metrics Feed Each Other
• Analysis Tools
• FindBugs
• PMD/CPD
• Testing Metrics
• Cyclomatic Complexity
• Chidamber and Kemerer Object-oriented Metrics
• JDepend
• Code Change Risk Analyzer and Predictor for Java
• Panopticode
• Tools

By Neal Ford

Most developers think that "TDD" stands for Test-driven Development. But it really should stand for "Test-driven Design". Rigorously using TDD makes your code much better in multiple ways.

This session demonstrates how stringent TDD improves the structure of your code. I discuss TDD as a technique for vetting consumer calls, using mock objects to understand complex interactions between collaborators, and some discussions of improved code metrics yielded by TDD. This session shows that TDD is much more than testing: it fundamentally makes your code better at multiple levels.

By Neal Ford

You can read books about Agile projects, but you must consult real-world experience to really understand the dynamics of agile project management. This session discusses agile management topics including estimation, project tracking, and useful metrics (and how to obtain them). And just a little about Mingle, the agile project tracking tool from ThoughtWorks.

OK, sure, you can read the XP Explained book. Now what? Agile project management in the real world requires understanding of not just the practices but why they work. This talk delves into several topics relevant to agile project management, including estimation, project tracking, accurate project metrics (and the practices that make them possible). This talk is designed to describe some of the nuances required to handle real agile projects, along with a demonstration of some of the artifacts ThoughtWorks uses to track projects (the most elaborate spreadsheet you've ever seen!). And, towards the end, I show how our experience has culminated into Mingle, the agile project tracking tool from ThoughtWorks with skinnable religion.

By Neal Ford

It turns out that ancient philosophers knew a lot about software -- did you know that Plato defined object-oriented programming? This keynote applies old lessons to new problems and old problems to new lessons. It describes why SOA is so hard, and why people in your company make bone-headed decisions. What other keynote includes Rube Goldberg, Aristotle, Dave Thomas, and Chindia?

Plato, Aristotle, Occam, Rube Goldberg, Dave Thomas, and Demeter...with pictures!

By Neal Ford

This session talks about how to actually get XP done in the real world (and what to tell your boss).

Extreme programming sounds a little too ?ESPN2? for most managers, but there is a lot of sound engineering behind its principles. My employer, ThoughtWorks, has been extremely successful using the full XP stack and we have developed lots of experience with it. This session talks about how to do XP in the real world. XP is all about feedback loops, so I discuss how to replace the radical sounding ones with more palatable ones. I talk about the parts of XP that are absolutely vital (unit testing, collective ownership, continuous integration, etc) and the ones that you can introduce a little more slowly (pair programming, only a 40 hour work week). This session focuses on the practicality of XP and how you can adopt it at your organization. I also talk about political battles with managers, other departments, and barriers that pop up anytime you try to introduce change in a large enterprise. Discussion is encouraged (required) in this session.

Key Session Points: XP and Feedback Loops A pragmatic look at the XP practices     The planning game     Small releases     Metaphor     Simple design     Testing     Refactoring     Pair programming     Collective ownership     Continuous integration     40-hour week     On-site customer     Coding standards XP in the real world

By Neal Ford

This session demonstrates that "Agility" and "SOA" complement each other quite well. Just because SOA is buzz-word compliant doesn't mean that you should throw good practices out the window. This session demonstrates how you can apply the principles of agility to building highly complex distributed enterprises.

Managers and ivory tower architects seem to think that all the rules that apply to "normal" software don't apply to SOA. Ironically, they matter even more. Agility and SOA are closely aligned because SOA is about building complex distributed systems and Agility is about effectively building complex software. This session unveils the pillars of successful SOA and how to achieve them in a testable, iterative fashion. It discussing testing strategies, how to make your architecture more robust and maintainable, and how to design an evolutionary architecture.

By Neal Ford

This session describes JRuby, the 100% pure-Java implementation of the Ruby programming language. It covers the basics of programming with JRuby and examples of how to integrate it into existing Java projects.

Like hamburger & fries and turkey & dressing, JRuby allows you to harness the awesome power of Ruby in your Java projects. This session describes the origins, capabilities, and limitations of JRuby, the 100% pure-Java implementation of the Ruby programming language. This session also demonstrates some areas where it makes sense to mixin Ruby and Java code: Rails on Java, testing, and dynamic programming. JRuby is a powerful implementation of Polyglot Programming, and this session shows you how to leverage this cutting-edge concept.

Session Topics:

• JRuby's origins
• Calling Java from Ruby
• Calling Ruby from Java
• Limitations and pitfalls
• Example usage
• Rails on Java
• Testing
• Dynamic programming
• The future

By Neal Ford

The Gang of Four book should have been entitled "Palliatives for Statically Typed Languages", because the recipes it provides are cumbersome solutions to the problems it poses. Using powerful languages makes the solutions in the GoF book look hopelessly complicated. This session shows how to solve the same problems concisely, elegantly, and with far fewer lines of code using the facilities of dynamic languages.

The Gang of Four book was actually 2 books: a nomenclature describing common software problems and a recipe book for solutions. The vocabulary they defined is still useful. The recipes are a disaster! Dynamic languages (like Groovy and Ruby) have powerful meta-programming facilities far beyond statically typed languages. It turns out that many of the structural design patterns in the Gang of Four book and beyond are much easier to solve with meta-programming. This session compares and contrasts the "traditional" approach of design patterns with a more nuanced meta-programming approach. Using language features creates cleaner abstractions with fewer lines of code and little or no additional structure. This session shows one of the many reasons that dynamic languages are such a hot topic.

By Ted Neward

Java's threading capabilities took a serious turn for the better with the release of Java5, thanks to the incorporation of the java.util.concurrent packages, a set of pre-built components for thread pooling and execution, synchronization, and more.

In this presentation, we'll explore the Thread API, the Java threading model beneath it, and the enhancements made in Java5 to make it easier for Java code to walk and chew gum at the same time.

By Ted Neward

Java's threading capabilities have been a part of the Java platform since its inception, yet for many Java developers, using Threads still remain a dark and mysterious art, and synchronization beyond the use of the "synchronized" keyword is almost unknown.

In this talk, we'll explore the Java "monitor" concept, and how a monitor isn't quite the same thing as a lock from other concurrency systems. We'll see how monitors can be used to perform signalling across threads, and then how the new java.util.concurrent API (introduced in Java 5) can be used to simplify the same sorts of tasks that used to require deep knowledge of the synchronized keyword. Finally, we'll answer that age-old question, "Why did the multithreaded chicken cross the road?"

Prerequisite: The Busy Java Developer's Guide to Concurrency (Part 1: Threads)

By Ted Neward

If you've ever gotten a ClassCastException and just knew the runtime was wrong about it, or found yourself copying .jar files all over your production server just to get your code to run, then you probably find the Java ClassLoader mechanism to be deep, dark, mysterious, and incomprehensible. Take a deep breath, and relax--ClassLoaders aren't as bad as they seem at first, once you understand a few basic rules regarding their operation, and have a bit more tools in your belt to diagnose ClassLoader problems. And once you've got that, and hear about ClassLoaders' ability to run multiple versions of the same code at the same time, and to provide isolation barriers inside your application, or even compile code on the fly from source form, you might just find that you like ClassLoaders after all... maybe.

For a beginning to intermediate Java audience.

By Ted Neward

Want to get the soup-to-nuts story on Java annotations? In this presentation, we'll first talk about what annotations provide to the Java language. After setting ourselves a conceptual basis to operate from, we'll look at the language definition for Java annotations, from how to use them to how to define them. Finally, we'll take a look at the other side of annotations, consuming them at source-level (using "apt", the annotation processing tool), class-level (using a bytecode toolkit such as BCEL), and at runtime (using enhancements to the Reflection API made in Java5).

For an intermediate Java audience.

By Ted Neward

Permissions, policy, SecurityExceptions, oh my! The Java platform is a rich and powerful platform, complete with a rich and powerful security mechanism, but sometimes understanding it and how it works can be daunting and intimidating, and leave developers with the basic impression that it's mysterious and dark and incomprehensible. Nothing could be further from the truth, and in this presentation, we'll take a pragmatic, code-first look at the Java security platform, including Permissions, the SecurityManager and its successor, AccessController, the Policy class and policy file syntax, JAAS, and more.

For an intermediate-level audience.

By Ted Neward

Ever since its 1.1 release, the Java Virtual Machine steadily becomes a more and more "hackable" (configurable, pluggable, customizable, choose your own adjective here) platform for Java developers, yet few, if any, Java developers take advantage of it. Time to take the kid gloves off, crack open the platform, and see what's there. Time to play.

In this presentation, we'll examine several of the "hackable" customization points inside the JVM: the boot classpath, allowing us to add or modify existing JDK classes without violating the license agreement; the JNI Invocation API, allowing us to create custom Java launchers to establish an environment for the JVM that corresponds to exactly the way we want it; or even replace core Java classes with our own versions. Innocents beware--we're a long way from "Hello, Java". (Attendees should have some familiarity with C/C++ code and native build practices to get the most out of this talk.)

By Ted Neward

Scala is a new programming language incorporating the most important concepts of object-oriented and functional languages and running on top of the Java Virtual Machine as standard "dot-class" files.

Sporting the usual object-oriented concepts as classes and inheritance, Scala also offers a number of powerful functional features, such as algebraic data types, immutable objects by default, pattern matching, closures, anonymous functions and currying, and more.

Combined with some deep support for XML generation and consumption, Scala offers Java programmers an opportunity to write powerful programs with concise syntax for a new decade of Java programming.

By Ken Sipe

Well the standards created EntityBeans.... yea. and the community created Hibernate. Fortunately the standards body learned some lessons and created JPA. JPA requires a vendor implementation and none make a better choice then Hibernate. Combined with Spring this trio is a powerhouse when it comes to developer productivity on applications requiring persistence.

This session will look at in detail the persistence capabilities of the latest Spring 2.5 and how to provide data access capabilities, including nicely added features for unit tests. We'll focus the persistence discussion on JPA and examine a number of ORM mapping scenarios and how JPA maps to them. We'll focus on the spring integration including transactional capabilities.

By Ken Sipe

Spring 2.5 is brand spanking new, with a number of fantastic features. With growth of large and complex Spring applications which struggle with xml manageability and with the added pressure of Guice and SEAM there is a push for less XML, with solution leaning towards annotations. Spring 2.5 adds to the toolset provided in Spring 2.0 to provide a development environment where XML is greatly reduced... or eliminated if you so choose.

The session walks through the new Spring 2.5 enhancements, then dives deep into annotation oriented injection. The demonstrations include standard applications as well as a look at the new Spring MVC.

By Ken Sipe

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

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

By Ken Sipe

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

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

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

By Ken Sipe

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

A look at the growing space referred to as ethical hacking or penetration testing. We'll look at example attacks which include: Client-side exploits Sql-Injections Brute force attacks Man-in-the-middle attacks Key logging

By Brian Sletten

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

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

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

This talk will introduce REST and walk through why it is so important and makes such a difference. We will talk about REST API design, security, long-lived systems, content-negotiation, contract enforcement, when REST might not make sense, etc.

REST and the Web Architecture are the basis for many exciting things happening on the Web and within our organizations. You owe it to yourself to make sure you really "get it".

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

By Brian Sletten

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

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

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

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

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

By Brian Sletten

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

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

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

By Brian Sletten

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

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

Don't worry, Javolution has your back.

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

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

Come see how you can get some of the time-determinism and concurrency benefits in either your client or server side applications. This is a fairly deep talk and is largely a decomposition of an API that changes the runtime characteristics of the VM's runtime performance with only the tools offered by the language and the VM.

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 a vision of machine-processable documents and metadata to improve search, knowledge discovery and data integration and management. The only problem is that there is no such thing. There is no Semantic Web, just the Web we have that is increasingly semantics-enabled.

Forget the hype. Come learn how the technologies of this vision are being used today on the Web and in the Enterprise by more people than you might think.

Attendees will learn:

The history and motivations behind the Semantic Web vision An honest assessment of where we are and what is likely to unfold The technology stack involved (including RDF, RDFS, SKOS and OWL) Tools built around this stack Introduction to how they can help you today

By Jeff Scott Brown

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

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

By Jeff Scott Brown

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

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

By Jeff Scott Brown

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

When Java developers are first introduced to Groovy one of the first things they notice is how much easier things are in Groovy compared to Java. Boilerplate code typically generated by your IDE all melts away to nothing in a Groovy bean. Creating XML is a snap, not a tangled mess. File I/O is a breeze. Those developer productivity gains are an important part of the story. However, in addition to making easy the things you are used to doing the hard way Groovy brings whole new capabilities to the party that Java developers don't even think about because you can't do those things with Java. Many of those capabilities are made possible because of the powerful metaprogramming capabilities of the language. Learning the metaprogramming capabilities of the language takes developers the rest of the way to fully taking advantage of the power of Groovy. The metaprogramming capabilities offered by the language provide everything that an application development team needs to build systems that are far more capable than their all Java counterparts.

Prerequisite: A Thorough Introduction To Groovy

By Jeff Scott Brown

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

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

• Introduction To Grails
• Domain Objects
• Controllers
• GSPs
• Custom TagLibs
• GORM

By Jeff Scott Brown

Grails makes web application development both fun and easy. This session dives beyond the basics to cover advanced details of Grails that bring the really exciting features to your applications.

Getting started building web applications for the Java platform is easy. Following that through to rich interactive applications that solve the business needs is more tricky. Grails goes the whole way to address pain points not only for simple applications but of real enterprise applications with real demands. This session steps through many of the advanced features of Grails that help get your applications through that last 20% that teams often struggle with.

Prerequisite: Grails - Agile Web 2.0 The Easy Way

By Venkat Subramaniam

Java has been around for well over a decade now. It started out with the goal of being simple. Over the years, its picked up quite a bit of features and along comes complexity. In this presentation we will take a look at some tricky features of Java, those that can trip you over, and also look at some ways to improve your Java code.

Java features Set of tricks Tips to improve your Java code

By Venkat Subramaniam

The first item in the Agile Manifesto reads that we must prefer "people and interaction over process and tools." Given a choice between average people with superior tools and superior people with average tools, you are likely to achieve greater success with the latter. However, it is important to be continuous and not be episodic?so you want to get continuous feedback about the state, health, and quality of your code and application. Tools can help us a great deal to realize this and make us productive.

In this presentation we will take a look at tools (and their relevance and value) that can help smoothly execute your projects.

By Venkat Subramaniam

DSL or Domain Specific Languages focus on a domain or problem at hand. They're expressive, but their restricted scope keeps them simple and small from the user point of view. However, designing them is not easy. In this presentation we will explore the features of Groovy and show how they can be used to create DSLs.

What's DSL? Characteristics of DSLs Types of DSLs Designing DSLs Groovy features that enable DSLs Examples of DSLs in Groovy Creating DSLs in Groovy

By Venkat Subramaniam

How do you ensure your applications meet the expectations of your key customers? In this session we will explore using the FIT tool and Behavior Driven Design tools to do exactly this.

Unit Testing helps you, the programmer, verify your application meets and continues to meet your expectations. But how do you ensure that your application meets and continues to meet the real expectations, those of your domain experts and key customers? We will take a look at two distinct approaches for customer acceptance testing. We will take a look at using FIT for testing behavior and at Behavior Driven Design tools and techniques. Both these approaches can helps us create what is called executable documentation and to stay sane in the world of changing requirements and evolutionary design.

By Venkat Subramaniam

Unit Testing is easy if the object you're testing has no dependencies. In reality, however, objects have dependencies, often making it difficult, if not impossible, to automate tests. Mock objects can help deal with these dependencies and allow you to automate your tests.

In this presentation you'll learn what mocks are, the difference between mocks and stubs, how to hand toss mock objects, how to approach testing with deeper dependencies, and also how to use tools and framework that can help you with mocking.

By Venkat Subramaniam

A good design is critical for success with agile development. That does not mean a big up-front design. The design has to be evolutionary. However, the design you evolve must be extensible and maintainable. After all, you can't be agile if your design sucks.

In this presentation, we will address what evolutionary design is, and will delve into principles and practices that can help realize an effective evolutionary design.

By Venkat Subramaniam

We all have seen our share of bad code. We certainly have come across some good code as well. What are the characteristics of good code? How can we identify those? What practices can promote us to write and maintain more of those good quality code. This presentation will focus on this topic that has a major impact on our ability to be agile and succeed.

Characteristics of quality code Metrics to measure quality Ways to identify and build quality

By David Geary

In April 2005, annual growth rates for jobs in JavaServer Faces, Struts, and Ruby on Rails were all at about 0%. Today, Struts' growth rate still hovers around 0%, but JSF and Rails have taken off. At the end of 2007, both JSF and Rails were growing at a rate of between 400-500% annually (according to indeed.com).

JSF has passed the adoption tipping point, and is now the Java-based framework of choice, as is evidenced by its ecosystem. From vendors such as MyEclipse and RedHat to open source projects such as Seam, Facelets, and Ajax4JSF, JSF is where the action is.

Come see why JSF is so popular. In this code- and demo-intensive session, I'll show you the fundamentals of JSF.

This session is taught by a member of the JSF Expert Group for JSF 1.0 and 2.0., and co-author of the best-selling book on JSF: Core JavaServer Faces. David will take you through a whirlwind introduction to JSF including what JSF is, how it was developed, and how you can best take advantage of the technology. Here is a list of topics:

Components, managed beans, value expressions, and static navigation i18n, CSS, and actions The Faces Context and Faces messages The JSF Event Model Using JavaScript with JSF

This introduction to JSF also contains 5 live-code demos, where David will develop a simple, but robust application during the course of the session.

Prerequisite: Some knowledge of Java-based web applications, such as Struts, is a plus, but is not required. If you have a significant experience with JSF, you probably already know most of what's covered in this session.

By David Geary

Facelets is a combination of Tiles and Tapestry, and it's the hottest JSF-related open source project on the planet. It's popularity is well deserved, and in fact, much of what is in Facelets today will make its way into the JSF 2.0 spec due out in 2008. So not only can you come to this session and see some really cool demos that you can put to use in the real world, but you'll also be learning JSF 2.0 before it's even been defined! How's that for a ROI?

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

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

By David Geary

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

The JSF spec has changed little since JSF debuted in 2004. However, the open source community is a frentic cauldron of activity that has produced lots of cool innovations, many of them related to Ajax. In this talk, we'll look at two of the most popular open source Ajax frameworks for JSF: Ajax4jsf and RichFaces.

Ajax4jsf gives you a very capable set of low-level Ajax tags (JSP or Facelets), along with their corresponding APIs, that let you easily incorporate Ajax features, most of the time by just using a custom tag or two. Ajax4jsf is an ideal solution if you want to add Ajax functionality to an existing JSF application.

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

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

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

By David Geary

Have you ever stopped to think that you need to learn two frameworks to develop a non-trivial, database-backed, web application? Struts and iBatis; JSF and Hibernate; Tapestry and EJB3.0. Two frameworks. And then you have to learn to use them together. Why do we have to learn two frameworks just to retrieve "Hello World" from a database and show it in a view. Isn't that crazy?

Now you can use one framework, and use one component model. One. Isn't that nice?

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

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

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

By David Geary

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

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

By David Geary

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

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

By Brian Sam-Bodden

Drools is an open source pure-Java implementation of a forward chaining rules engine. Drools can be used in a J2SE or J2EE application and allows you to express rules programatically or by building domain specific rule languages. Learn how Business Rules with Drools can make your Java applications more flexible and robust.

Software development is expensive, when business rules are hard-coded in your application's source code, changes and additions to those rules translate to wasted time and money. Good object-oriented, component-based approaches can alleviate the burden of keeping up with changes in the business world but they still require that expert knowledge of the changes be passed from the decision makers to the business analysts and finally to programmers that need to implement these changes. Business Rule Engines and Business Rule Languages are based on the basic premise of separation of concerns by empowering business domain experts to express the rules of business in a way that it is directly usable by applications. Drools is an open source pure-Java implementation of a forward chaining rules engine. Drools can be used in a J2SE or J2EE application and allows you to express rules programatically or by building domain specific rule languages. Learn how Business Rules with Drools can make your Java applications more flexible and robust.

By Brian Sam-Bodden

In this session you'll learn some of the more advanced features of Drools; a pure-Java Rule Engine. This session will walk through the construction of an advanced Rules application covering such topics as:

• Fine control and monitoring of a Working Memory session
• Using Decision Tables
• Advanced Rule Language Features
• Building Domain Specific Languages
• Managing your Rules

Many of the problems that we deal with in enterprises around the world are not usually related to the particular infrastructure, framework or programming language chosen but rather to the evolution and maintenance of the business logic that governs those systems. All knowledge in an enterprise is handed down stream until it arrives at the programmer's door. With Rule based systems we can empower those with the business but there is still a fair amount of work to get the ideal architecture for a particular problem in place. In this session you'll learn some of the more advanced features of Drools; a pure-Java Rule Engine. This session will walk through the construction of an advanced Rules application covering such topics as:

• Fine control and monitoring of a Working Memory session
• Using Decision Tables
• Advanced Rule Language Features
• Building Domain Specific Languages
• Managing your Rules

Prerequisite: Beginning Drools

By Brian Sam-Bodden

Learn how to build featured rich applications using the Eclipse Rich Client Platform. The Eclipse platform is an open tools platform, on top of this platform you can build your own applications (which do not need to be IDE like or IDE related). Yet you can enjoy the benefits of working with a mature and featured rich platform that can greatly reduce the amount of time required to create a professional-looking and robust Java UI application.

Learn how to build featured rich applications using the Eclipse Rich Client Platform. The Eclipse platform is an open tools platform, on top of this platform you can build your own applications (which do not need to be IDE like or IDE related). Yet you can enjoy the benefits of working with a mature and featured rich platform that can greatly reduce the amount of time required to create a professional-looking and robust Java UI application. In this session learn the foundations of building Eclipse RCP applications, including SWT and JFace and we will use the concepts learned to create a professional looking Java application that can rival any .Net application.

By Brian Sam-Bodden

Mylyn is a task-focused toolkit for the Eclipse IDE that allows developers to focus on tasks in a way that they never been able to do before. Mylyn eliminates the constant context switching produced by typical ways IDEs are used. No more scrolling/browsing/searching/tagging/sending emails with progress updates... Mylyn provides a new way of working that allows you to focus on specific tasks by reducing information overload. Mylyn also provides a framework for integrating with the most commonly usage task tracking systems and version control systems. In this talk you'll learn how Mylyn can boost your productivity as a Java developer by letting you get the most out of your IDE.

Mylyn is a task-focused toolkit for the Eclipse IDE that allows developers to focus on tasks in a way that they never been able to do before. In this talk you'll learn how Mylyn can boost your productivity as a Java developer by letting you get the most out of your IDE.

By Brian Sam-Bodden

Hibernate is an open source Object-Relational Mapping Framework that mostly automates the tedious and time-consuming task of persisting Java objects to a relational database. Hibernate is quickly becoming the preferred way for enterprise developers to overcome the object-relational impedance mismatch and a good alternative to the coarse-grained Entity EJBs, low-level raw JDBC, and by-committee specifications like JDO. Learn what your choices in the ORM arena, what to look for in an ORM tool, and how to get started with Hibernate for your next J2SE or J2EE project.

Hibernate is an open source Object-Relational Mapping Framework that mostly automates the tedious and time-consuming task of persisting Java objects to a relational database. Hibernate is quickly becoming the preferred way for enterprise developers to overcome the object-relational impedance mismatch and a good alternative to the coarse-grained Entity EJBs, low-level raw JDBC, and by-committee specifications like JDO. Learn what your choices in the ORM arena, what to look for in an ORM tool, and how to get started with Hibernate for your next J2SE or J2EE project.

In this session you will learn: - Understanding the O/R Impedance Mismatch - Techniques of O/R Mapping - Persistence Frameworks in Java - Architecting Persistence into your application - Hibernate Architecture and Overview - Installing and configuring Hibernate in J2SE - Hibernate in a J2SE application - Mapping Persistence Classes - Domain Models - Object Identity - Dealing with Inheritance and Schema Associations - Understanding the lifecycle of persistent objects - Understanding Hibernate usage in a J2EE application - Overview of advanced topics

By Brian Sam-Bodden

Learn 10 tried and true ways to improve the way you use Hibernate today. In this session you would learn about a collection of 10 tips, tricks, practices and tools that will make you more effective at designing, implementing, testing and tuning your application's Hibernate-powered object-relational layer.

Learn 10 tried and true ways to improve the way you use Hibernate today. In this session you would learn about a collection of 10 tips, tricks, practices and tools that will make you more effective at designing, implementing, testing and tuning your application's Hibernate-powered object-relational layer.

Some of the topics covered include: - Handling and implementing inheritance - Caching - Profiling your queries - Using filters for virtualization - Custom SQL for performance - Query caching - ... and more