By Ben Hale
Spring 2.0 has marked a major advance in the Spring Framework. While still maintaining backwards compatibility, this release adds quite a few new features. What are those features and how do they add value? Come by and see.

In this session we'll provide a practical tour of what's new in Spring 2.0. Spring 1.x users who are looking to upgrade to Spring 2.0 will love this session. If you're not using Spring already, this talk will give a great overview of the things you're missing out by not using Spring 2.0.

The talk will highlight new configuration strategies, Spring AOP, bean scoping, JPA support, JMS improvements, new Spring MVC features, VM languages, and much more.

By Ben Hale
To today's JEE developer, there are two indispensable tools for creating applications; Spring and Hibernate. Together these two frameworks comprise one of the most powerful and often used stacks in the industry. While it is possible to do amazing things it's not always obvious how best to use them to maximize value. This session aims to correct that.

In this session, we'll start by addressing the basic design of an application using Spring and Hibernate. Once we've established some baseline best practices, we'll focus on how to best use Hibernate (both 2 and 3) in the persistence tier. We'll take a look at the use of Spring's HibernateTemplate and some new strategies in Spring 2.0. To finish with a look to the future, we'll explore use of JPA (Hibernate implementation) with Spring 2.0.

By Ben Hale
Security is one of the major requirements in modern day enterprise applications and yet it is also one of the weakest parts of most developers toolboxes. The problem is of course that security is HARD! It turns out that rather than reinventing the wheel for each application, developers can turn to a great security framework out there already; Acegi.

In this session we'll discuss a little known but widely used Spring sub-project called Acegi Security. Acegi is a great tool for implementing security at the URL, method, and domain object layers and can greatly simplify security requirement fulfillment for enterprise applications. The first part of the session will focus primarily on some basic security concepts and where Acegi fits into the equation. The second part of the session will focus on basic design and usage principals of Acegi. The final segment will be a live coding example where we actually take an application and add all three levels of Acegi security to it. As a bonus, I'll even tell you the story of how the Acegi name came about :)

By Ben Hale
You're winding down a project and you get that dreaded email from your project manager, "How hard would it be to add some performance monitoring to the system?" Well, after this session, you'll be able to respond, "No problem at all!" It turns out that with a pinch of AOP and a dash of JMX, you can introduce amazing management and monitoring capabilities without changing your mainline code one bit.

In this session, we explore the technologies of AOP and JMX and how they can be used together to transparently add management and monitoring in a completely non-invasive way. We'll explore some of the various AOP packages including Spring AOP and AspectJ and how they can be used to apply management and monitoring inline to an application. Once we've added this functionality we'll how to expose it using JMX using Spring's JMX support and consume it using JConsole or Spring.

If you're tentative about introducing AOP or JMX into your application, come take a look at some of the cool things you can do with them and how easy it can be.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

By Brian Sletten
Ever since we started doing relational joins, we've looked for ways to tie data together. The web has given us no end of new data sources to integrate but it seems like the best we can come up with is locating Starbucks on Google Maps. The problem with browser-based mashups is that they don't survive the session, we have no way of referring to the results in future queries and ultimately we don't maintain ownership or control of the process.

We want control of our data and our mashup results. We want ever more ways to view, explore and requery them in multi-faceted ways. Do you know what your data integration strategy is for the next few years? Are you sure? You owe it to yourself to come find out.

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

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

Come listen to a discussion about these next generation technologies that are available now. This is probably most accessible to upper intermediate attendees with broad backgrounds, but will have some fun demos and will paint a picture of what is on the verge of being available to just about anyone who consumes and produces data.

By David Bock
For several years, I was a member of a team of people caught in the middle of a 200+ person software development company, with senior management wanting "buzzword compliant process improvement" such as CMMI, and engineers wanting more ?agile? solutions (and people on both sides confusing Agile with ad-hoc). We were responsible for sorting it all out. Reconciling this was a herculean effort, and can be a source of lessons learned for your own process improvement efforts. Are you trying to be more agile in your organization? Are you expecting it to be harder than it needs to be because of political and bureaucratic forces beyond your control? Do you have to "educate" your senior management to protect them from buzzwords? Come learn from my successes... and mistakes.

Introducing change into a large organization can be difficult, even when everyone is in agreement. By starting with 'the quick win' and fixing some real pain in your organization, you can begin to get people moving in the right direction. In this talk we will look at the kinds of quick process wins that are possible, and how to introduce new ideas into a large organization.

By David Bock
Internationalization and Localization in Java is easy, right? Everyone knows you just store your strings in some resource bundles, set the locale, wave your hands a little bit, and your application is good-to-go. Right? Maybe not... Java provides some great utilities to get started, but leaves you needing more when it comes to things like screen layout, cultural sensitivities, semantic differences in translation, use of color and iconography, and other issues.

This presenter spent 9 years developing applications for the U.S. State Department that have been deployed in dozens of countries and languages. While some aspects of internationalization and localization are trivial, there are plenty of issues that are not. If you have an application that you expect to localize into other locales, there will be information here that is invaluable to you. This talk is entertaining for the war-stories alone! No other no-fluff presentation will feature pictures of the presenter waiting in line behind a herd of sheep to cross a pontoon bridge into Bosnia.

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
An introduction to the popular Prototype JavaScript framework, and two frameworks built on top of Prototype: Scriptaculous and Rico.

Web2.0 is all about rich, interactive user interfaces (UIs), and these three frameworks provide the capabilities that you need to develop those UIs.

Prototype (prototype.conio.net) is a low-level JavaScript framework that adds significant features to JavaScript that make it easier for you to use the language and to incorporate Ajax calls in your applications.

Scriptaculous is a framework (script.aculo.us) built on top of Prototype that adds some pizazz to Prototype with features such as a wide array of special effects, animation, and drag and drop.

Rico is another framework (openrico.org) built on top of Prototype that, among other things, provides something known as behaviours, where you adorn plain-vanilla HTML with seemingly magical behaviours.

Come to this session and learn how to harness the power of these three frameworks.

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

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

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

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

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

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

By David Geary
In this session, see how you can get Ruby On Rails-like productivity on the Java side of the house with this compelling combination of technologies.

JSF has been out for nearly three years now, and in many respects, the JSF specification has become a bit long in the tooth. Fortunately, the open source community has picked up the ball in a big way. In this 2-session presentation, we will explore three open source projects based on JSF--Seam, Facelets, and Ajax4jsf-- that will propel you into the stratosphere of productivity.

Seam is a framework from JBoss that combines the JSF and EJB3.0/Hibernate 3.0 frameworks into one component model. That means you only have to learn one framework to build compelling web applications.

This is the first of a two-part session, where we'll focus mostly on the Seam framework.

By David Geary
A continuation of a 2-session presentation on Seam, Facelets, and Ajax4jsf.

In the second part of this 2-session presentation, we'll turn our attention to Facelets and how you can use this compelling display technology with Seam.

We will also discuss Ajax4jsf and demonstrate how you can use that framework to create rich, interactive user interfaces for your JSF-based web applications.

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

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

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

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

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

By David Geary
The second part of a 2-session presentation on the Google Web Toolkit.

In this session, we'll dive deeper into the GWT and explore some of it's more advanced aspects, such as implementing custom widgets, deploying your application in a servlet container, and implementing drag and drop.

By Glenn Vanderburg
Ajax applications have unique design and architectural challenges and opportunities. This presentation will show you how to take advantage of the Ajax's strengths, and work around its quirks.

We'll start with an overview of Ajax, and then dive right into an extended example where we add Ajax to an existing web application. Along the way we'll cover several tools that we use to aid in Ajax development: The JavaScript Shell, Firebug, and the Web Developer's Toolbar. We'll also look at two popular JavaScript Ajax libraries: Prototype and Scriptaculous.

With the example application under our belts, we'll move to a discussion of Ajax architectural questions, including:

How do I select an Ajax library?
What format data should my Ajax calls use: XML, JSON, HTML, or other?
How do I handle the back button and deep linking in Ajax?
Prior exposure to Ajax and JavaScript is useful but not required.

By Glenn Vanderburg
With the sudden importance of Ajax, it's time to take JavaScript seriously. That means learning it the right way: looking at the fundamentals of the language and surveying its strengths and weaknesses, instead of just copying other people's poorly written examples.

JavaScript got a bum rap. It's almost universally derided among serious programmers for being a toy language, or for its strange characteristics, or bugs, or slowness, or because it's only good for adding useless window dressing to web pages.

But JavaScript is actually a very nice little language which is popping up everywhere these days (not just in Ajax apps). Sure, JavaScript is quirky, but its problems are mostly due to history, association, and misunderstanding. Especially misunderstanding. Let's face it: most developers learned JavaScript by looking at examples in web pages they found online, and few of those examples are paragons of JavaScript style. Other developers learned JavaScript from books, but the typical JavaScript book ignores the fundamentals of the language, instead focusing on examples and the fastest ways to do fancy web page tricks.

In this talk, we'll go back to the basics that most JavaScript resources omit. We'll talk about JavaScript as a language, learning its fundamental concepts and the simple rules that underlie the sometimes bewildering behavior.

By Glenn Vanderburg
Building on part 1, this talk dives deep into JavaScript's object model. We'll see how it differs from more mainstream object-oriented languages, and why. We'll explore how to hide some of those differences, as well as the reasons you might not want to. Additionally, we'll cover useful tools for JavaScript testing, debugging, and profiling.

Ajax is not the focus of this talk, but a strong foundation in JavaScript is essential for working with Ajax.

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

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

By Glenn Vanderburg
The early years of computers -- the '50s and '60s -- were characterized by furious exploration of a huge variety of different ideas. Since then many of the hot topics of those days have moved to the fringe, largely ignored by the mainstream of software development. But some of them are being rediscovered, and a lot of what we think of as "new developments" are really just some old ideas returning to center stage.

This talk will trace the roots of some contemporary software trends back to their origins before most of us were born.

By Jared Richardson
How do you keep a team scattered across time zones in sync?

It's difficult to keep a local team coordinated. When we add geographical distance to the equation, problems are immediately magnified. We'll talk about techniques that you can use to be sure everyone is sharing information and on the same page whether they're in the same office or in different time zones.

By Jared Richardson
An overview of the Agile software approach from the book Ship It! A Practical Guide to Successful Software Projects.

This book provides a comprehensive look at the software life cycle and can be used to retool the way you, and your team, builds software. While we can't cover the entire book in nintey minutes, we can look how a holistic view of the software life cycle helps you improve your projects and makes your life easier.

By Jared Richardson
A great team builds great software, but how do you build a great team?

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

By Jason Rudolph
Grails is an open-source web application framework that's all about getting things done. Grails combines best-of-breed Java technologies (including Hibernate and Spring), convention over configuration, and the powerful and dynamic Groovy language. Together with these elements and Groovy's ability to seamlessly integrate with your existing Java code, Grails finally legitimizes rapid web application development for the Java platform.

In this presentation, we'll see first-hand how to use Grails to build a fully-functioning and flexible web application in minimal time. As we develop the application, we'll explore the Grails project structure, its MVC elements, and the power of dynamic methods. We'll see how Groovy's highly-expressive nature allows us to write concise code, and Grails' use of sensible defaults and convention-over-configuration save us from much of the coding and configuration we'd otherwise face with many traditional frameworks.

By Jason Rudolph
Have you seen someone develop a Rails or Grails application in a matter of minutes, only to later discover that their domain model and database schema followed conventions that are different from your existing systems? Or perhaps you're interested in using Grails, but you don't want to duplicate your existing Java domain classes in Groovy. In this session, we'll see how Grails makes it easy to hook into your pre-defined schemas or existing entity classes, while still getting all the rapid application development (RAD) goodness that Grails has to offer.

In an enterprise environment, you're no doubt surrounded by legacy schemas that pre-date Grails by many years, possibly even a decade or so. You want to develop web applications quickly with one of the next-gen frameworks, but there's no chance that management will agree to change all the schemas just so you can code your app using the conventions employed by the next big thing. However, we'll see that with a bit of Hibernate XML or annotations, we can easily wire together our Grails domain models to our existing schema and still get most of the RAD benefits of Grails, including the super-productive dynamic finders. We'll discuss how to deal with various relationship types, non-trivial primary keys, and other database-related challenges.

In another big business scenario, you may find that you already have EJB3 entity beans lying around, perhaps powering some back-end B2B applications. The time has come to build a web front-end for those applications, and you logically want to reuse your current domain classes. With a few simple steps, we'll see how to use those entity beans as your Grails domain classes, and how your EJB3 domain models suddenly get all the benefits of Grails scaffolding, highly-configurable validation rules, powerful Hibernate criteria builders, and more.

By Neal Ford
This talk avoids SOA hype and gets to the meat of the matter: how do you implement a Service-Oriented Architecture, what are the technological pitfalls, how do you test it, and what traps should you avoid. No marketecture: just implementation details.


No subject has been subject to more recent hype than Service-Oriented Architecture (I think it was because of a really good article in an in-flight magazine). For whatever the reason, the CxO has decided that we need one. It's up to you to implement it. This session is all about the technical considerations required to implement a service oriented architecture. It discusses technology choices, what is in (and out) of SOA's scope, how to implement transformations, routing, and other key services, how to version endpoints, and finally testing and debugging SOA. This session is marketecture free: it covers the details you need to implement this style of architecture.

Session Topics:

• What SOA means to those who must implement it
• Technology choices
• Routing
• The WS deathstar
• MOM
• Implementing transformations
• Versioning services
• Testing SOA
• Debugging SOA implementations

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
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
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
No one writes perfect code: even the best developers fall into bad habits and traps. These topics from The Productive Programmer illustrate blind spots and helps you write better code.

It is too easy to get into a coding slump and not realize it. This talk revitalizes your relationship to code, forcing you to rethink some of the thing that you take for granted and showing new approaches to solving hard problems. It covers topics that range from improve the overall structure of your code to the way you write JavaBeans, with lots of examples. Everything in this talk may not be new to you, but I guarantee that you'll see some things that will make you reevaluate the way you think about your code.

Session Outline:

1. TDD
2. Static Analysis
3. Good Citizenship
• getters and setters
• Constructors
• Static State
4. YAGNI
5. Occam and His Razor
6. Question Authority
• DSLs
• JavaBean Specification
7. SLAP
8. New Languages
9. Every Nuance
10. Anti-objects

By Neal Ford
This session discusses building Domain Specific Languages and DSL-style code in Java, Groovy, and Ruby. It discusses the different types of DSLs, details on how to implement them in Java, Groovy, and Ruby, and example problem domains where DSLs make sense.


You've heard all the hype for the past couple of years: Domain Specific Languages (DSLs) are going to take over the world. This session demystifies this topic in 2 ways: by providing concrete definitions for styles and applicability of DSLs and showing how to implement these different styles. I build up definitions for the different types of DSLs in static (Java) and dynamic (Groovy and Ruby) languages. Then, I discuss building DSLs as internal (i.e., built on top of an underlying language) and external (built using a preprocessor or grammar), with examples of each. Throughout this session, I discuss the applicability of this style of development and show targeted examples. I discuss fluent interfaces and techniques for building them, including problems. Incidentally, I show some cool language features of both Groovy and Ruby that make building DSLs easier in those languages.

Session Topics:

• Why DSLs
• Abstraction
• Internal vs. External DSLs
• Fluent Interfaces
• Building Blocks
• Internal DSLs
• In Java
• In Groovy
• In Ruby
• The Stopping Problem
• Best Practices and Applications

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
This session explains all the hype surrounding Ruby on Rails, in a context familiar to Java developers. It covers convention over configuration, ActiveRecord, controllers, views, Ajax, scaffolding, testing, and deployment...on the JVM, using JRuby.

Find out why everyone won't shut up already about Ruby on Rails! This web framework for Ruby has appeared from nowhere to become the critics darling: there must be good reasons why. This session shows those reasons, in a context familiar to Java developers. It discusses how configuration works in Rails, persistence through ActiveRecord, scaffolding, controllers, views, and Ajax. It also covers the important topic of testing, and how Rails makes it easy and automatic. Finally, this session discusses deployment on the JVM, using JRuby, and reflects back on the important lessons that Rails teaches Java developers. This session also presents information about the boundary between Rails, Ruby, and JRuby.

Session Topics:

• Why Ruby? Why Rails?
• Getting started
• JRuby and Rails
• Convention over configuration
• Scaffolding
• ActiveRecord: Persistence done right
• ActionPack
• • Controllers
  • Views
  • Ajax for free
• Testing
• Deployment
• Reflection

By Scott Davis
This is the year of the dynamic scripting language. Ruby (and Rails) has won the hearts and minds of many independent software developers. JavaScript is experiencing a renaissance thanks to the wild success of AJAX and websites like Google Maps. And Groovy (JSR-241) brings the same level of excitement and "scripting goodness" to the Java platform.



In this presentation, we take a very pragmatic "prove it in code" approach to learning Groovy. Since the syntax is (almost) identical to Java, we can dive right in from the very beginning, learning the "syntactic sugar" as we solve real world problems.

You'll learn how easy it is to install Groovy and get started working with it. You'll tackle file I/O, reading and creating text files. You'll create and parse XML and HTML. You'll interact with databases. You'll create Groovlets (servlets sprinkled with Groovy-dust). And finally, you'll get a brief introduction to Grails (hint: the 'G' is silent).

By Scott Davis
I'm attracted to Groovy because of its spirit of inclusiveness. Because it extends my platform of choice, not replaces it -- include a single JAR in your classpath and you are Groovy-enabled. Because it offers full bidirectional integration with Java. Because it offers a nearly flat learning curve for experienced Java developers. Come see how you can use Groovy to augment your existing Java codebase.


We'll look at calling Groovy from Java. We'll look at calling Java from Groovy. We'll look at compiling Groovy code, JARring it up, and deploying it alongside Java.

Groovy offers the same level of integration with Ant. We'll look at Ant tasks that allow you to include Groovy in your build process. Or maybe you'd prefer to use the Groovy AntBuilder and completely manage your build in code. The choice is yours. The important thing is Groovy works along side your familiar toolkit instead of forcing you to replace it.

By Scott Davis
Scott Davis is the Editor in Chief of aboutGroovy.com. The website, in addition to being, umm, about Groovy, is implemented in Grails. This talk shows you how to get started with Grails, but also talks about the experience of using it in a live, production web site.

Grails is a fully integrated, modern Java web development stack. In a single zip file, it includes a web server (Jetty), a database (HSQLDB), a build system (GANT, a Groovy/Ant hybrid), a logging framework (Log4J), and a unit testing framework (JUnit). It also includes mainstream libraries like Spring for dependency injection, Hibernate for Object/Relational mapping, Quartz for scheduling, and SiteMesh for page layout. For Ajax, Grails allows you to choose between three major included technology stacks: Prototype/script.aculo.us, the Yahoo UI library, and Dojo. Coupling the power of these mainstream libraries with the ease-of-use that Groovy offers, you have an unprecedented collection of technologies that will have you up and running in record time.

Grails maximizes the strengths of these familiar Java libraries while minimizing the XML jockeying it usually takes to get them all to play nicely with one another. It brings "Convention over Configuration" to Java. It uses Groovy as the language to glue the pieces together, which means that experienced JEE developers can learn Groovy in the context of libraries that they are already familiar with.

It is no exaggeration to say that you will have your first Grails application up and running in minutes. But Grails is more than about a quick start. In this talk, we'll look at ways to move beyond the default configurations. We'll deploy a Grails app to an external Tomcat instance instead of the included Jetty server. We'll move from the default HSQLDB database to MySQL. We'll include external JARs to bring new functionality to the mix.

By Scott Davis
"Which framework should I use?" is the question most often heard on the No Fluff, Just Stuff tour. It's well worth asking. Unfortunately, there is no simple answer. After years on the tour, most speakers have crafted a response that would make any Washington politician proud -- long on style, but essentially, "Well, it depends..."

In this humorous keynote, Scott Davis turns to unconventional sources for enlightenment. Could best-sellers like Blink, Freakonomics, The Tipping Point, The Paradox of Choice, and The Wisdom of Crowds finally solve the puzzle? In this "Da Vinci Code"-like romp through the conventional wisdom of the day, will the Holy Grail of web frameworks be revealed? Probably not, but possible side effects may include nausea, dry mouth, and insight into the eternal question of our industry.

By Scott Davis
Google quietly deprecated their SOAP search API at the end of 2006. While this doesn't mean that you should abandon SOAP, it does reflect a growing trend towards simpler dialects of web services. Google joins a number of popular websites (Yahoo, Flickr, YouTube, del.icio.us) that offer all of the benefits of web services without all of the complexity of SOAP.

REST isn't a specification or a framework -- it's a set of architectural principles. This means that you can begin using it immediately. No framework wars, no version mismatches. This talk demonstrates some of the more popular RESTful web services out there in the wild. It also shows you live examples of how to implement your own.

We'll look at the simplest form of REST -- GETful web services. We'll also look at more sophisticated RESTful interfaces that utilize all of the HTTP verbs (GET, POST, PUT, and DELETE) and MIME types. Finally, we'll look at Atom and the Atom Publishing Protocol -- the RESTful implementation that Google chose to replace its aging SOAP implementation.