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
Hibernate is rapidly becoming the tool of choice when it comes to Object-Relational Mapping in Java. For simple applications with fairly simple object models and database schemas, using Hibernate is fairly straight forward. Unfortunately for most of us real applications have complex object-models that need to be wired to sometimes ancient and convoluted database schemas.

In this session we explore some of the advanced features of Hibernate and how you can use Hibernate to solve the hard problems of Object-Relational Mapping.

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
Ant has revolutionized the way we build applications in Java and it has become a de facto standard in the Java world. As applications grow in complexity some developers are finding themselves dealing with ever growing and complex builds. Complex builds have to deal with Multiple Operating System, multiple Application Servers, multiple APIs and multiple stages of development.

This talk would highlight some of the growing pains typically encounter in the evolution of an application build system and possible solutions and best practices that can be applied to several of these scenarios. With the arrival of the Ant version 1.6 many of the lessons learned with large projects have been now incorporated. Ant 1.6 can help you deal with complex builds efficiently.

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 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 Jared Richardson
Agile practices are popular because they work, but getting people to take that first step can be tricky.

We'll look at how continuous integration was successfully introduced to a very large, established software shop and used to introduce other Agile practices. Let's see what lessons we can draw from this example that you can take back to your shop.

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
Continuous Integration is increasingly recognized as a vital practice in an Agile software shop. Traditionally it's been difficult to set up and administer. Today, that's no longer the case.

We'll look at Cruise Control, a popular CI package. We'll start with the "quick-start" binary release, then change the set up to point to our own project. When we're done, you'll be able to set up your own Cruise Control install on Monday morning.

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
Creating and maintaining a solid automated test suite is critical to an Agile strategy, but often we're just told to "Do it." In this talk we'll look at several pragmatic strategies for creating and building your suite.

We'll examine these strategies and then look at scenarios for using them next week. This presentation will get you started whether you're starting a new project or trying to clean up an existing one.

By Jared Richardson
Throughout our software careers we learn habits from our coworkers, from books we've read, and occasionally, from conferences we attend. Much of our competence comes from the tips and tricks we pick up as we go.


In this session, learn five of the techniques I've borrowed along the way. We'll discuss The List, code reviews, code change notifications, daily meetings, and tech leads. These techniques are often abused, but when used properly they can make a huge difference in how you develop software. Take this opportunity to add these practices to your toolkit.

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 Nathaniel Schutta
When starting a new project, most developers make sure that testing is a priority. However, only the lucky few live in the idyllic world of greenfield development; the vast majority of us must contend with code written when "test" was a four letter word and testing was the sole responsibility of that "other" organization. We'll examine some techniques for introducing testing - not just to your code but to the rest of your development organization.

When starting a new project, most developers make sure that testing is a priority. However, only the lucky few live in the idyllic world of greenfield development; the vast majority of us must contend with code written when "test" was a four letter word and testing was the sole responsibility of that "other" organization. We'll examine some techniques for introducing testing - not just to your code but to the rest of your development organization.

By Nathaniel Schutta
Ajax might not be the most complex thing the average web developer has ever encountered but that doesn't mean building Ajax applications is without some quirks. While you can certainly use the raw technologies beneath Ajax or even roll your own framework, there are a number of well-designed open source libraries that you can take advantage of. After providing a quick survey of the field, this talk will feature live coding examples comparing and contrasting some of the more mature Ajax toolkits including Dojo, Prototype, script.aculo.us and YUI. We'll show you what these various libraries do and do not provide and give you some ideas about which ones make the most sense for your needs.

Ajax might not be the most complex thing the average web developer has ever encountered but that doesn't mean building Ajax applications is without some quirks. While you can certainly use the raw technologies beneath Ajax or even roll your own framework, there are a number of well-designed open source libraries that you can take advantage of. After providing a quick survey of the field, this talk will feature live coding examples comparing and contrasting some of the more mature Ajax toolkits including Dojo, Prototype, script.aculo.us and YUI. We'll show you what these various libraries do and do not provide and give you some ideas about which ones make the most sense for your needs.

By Nathaniel Schutta
So you've convinced the boss that your new web application just has to have Ajax...but now what? With dozens of libraries making even the most blinkish of interactions trivial, how do you decided where to sprinkle the magic Ajax dust? This talk will give a plain old boring "web 1.0" an Ajax facelift with a focus on improving the user experience providing you with a game plan for introducing Ajax to your world.

So you've convinced the boss that your new web application just has to have Ajax...but now what? With dozens of libraries making even the most blinkish of interactions trivial, how do you decided where to sprinkle the magic Ajax dust? This talk will give a plain old boring "web 1.0" an Ajax facelift with a focus on improving the user experience providing you with a game plan for introducing Ajax to your world.

By Nathaniel Schutta
To most software developers, the command line is the pinnacle of interface design however, most users find this approach a little lacking. Despite a lack of training, many software engineers are called upon to create user interfaces that won't cause their users to grab the pitchforks. In ninety minutes, you'll have the tools to build compelling interfaces.

To most software developers, the command line is the pinnacle of interface design however, most users find this approach a little lacking. Despite a lack of training, many software engineers are called upon to create user interfaces that won't cause their users to grab the pitchforks. In ninety minutes, you'll have the tools to build compelling interfaces.

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
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
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
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
About bridges, languages, engineering, polyglot programming, and the near future.

Other engineers sneer at us when we call ourselves "Software Engineers", and they have a point. This keynote discusses real comparisons between traditional engineering and the software kind. It also delves into what it will take to make our profession a real engineering discipline and the near future of languages and environments. Come see your future.

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 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 discusses how to use the Productive Programmer principles of acceleration, focus, and indirection to become a more productive programmer. This session describes these principles, but the primary focus of this session is demonstration of these principles with real-world examples.


In The Productive Programmer, David Bock and I identify 5 principles of productivity: this talk goes into great detail on 3 of those principles. The session defines the principles and describes their use, but the primary focus of this talk is on real-world examples of how you can use these principles to make yourself a more productive programmer. Acceleration covers keyboard shortcuts (including ways to make better use of them) in both IntelliJ and Eclipse. Focus describes how you can modify both the operating system and your code base to eliminate noise. Indirection shows how a simple concept can have profound effects, including how to share a common set of plugins across an entire Eclipse project. This talk includes tons of examples, all culled from real-world projects.

Session Topics:

• The Productive Programmer
• Acceleration defined
• Applying Acceleration
• Keyboard shortcuts
• Plug-ins
• Getting around in a hurry
• Launching stuff
• Focus defined
• Applying Focus
• Get out of the trees
• Searching several ways
• Code focus
• Avoiding the trash pile
• Indirection
• Applying Indirection
• links vs. shortcuts
• Sharing stuff
• Canonical plug-ins
• Environment isolation

By Neal Ford
This session discusses how to use the Productive Programmer principles of automation and canonicality to become a more productive programmer. This session describes these principles, but the primary focus of this session is demonstration of these principles with real-world examples.


In The Productive Programmer, David Bock and I identify 5 principles of productivity: this talk goes into great detail on 2 of those principles. The session defines the principles and describes their use, but the primary focus of this talk is on real-world examples of how you can use these principles to make yourself a more productive programmer. Canonicality (the DRY principle from The Pragmatic Programmer) discourages repeating artifacts in projects. This talk shows effective ways to avoid this repetition. For example, I show how to reuse documentation via a Subversion hook that posts comments to a Wiki with an RSS feed. Automation refers to making the computer do more work for you. This talk includes tons of examples, all culled from real-world projects.

Session Topics:

• The Productive Programmer
• Automation defined
• Applying automation
• Scripting with...
• Win XP
• Bash
• Unix shell/cygwin
• Ruby
• Groovy
• Case Studies
• Canonicality defined
• Applying canonicality
• Hibernate and code generation
• Documentation Part 1
• Documentation Part 2

By Roman Hustad
See the hacker's toolbox in action as various web applications are ripped open by exploiting simple software bugs. Common problems such as Cross-Site Scripting (XSS) and SQL Injection will be demonstrated and explained, along with more subtle vulnerabilities including privilege escalation, data tampering, and Cross-Site Request Forgery.

Even if you've seen XSS and SQL Injection before, advanced techniques will be presented that can slip through many protections. As a finale, the holy grail of web security will be broken with a Man-In-The-Middle attack on SSL. Although countermeasures are briefly covered, this is first and foremost a shock and awe presentation that will motivate you to secure your applications. Attendees will receive a CD with all the Hacme applications used during the presentation so you can practice your new 'skillz.'

By Roman Hustad
This session provides a gentle introduction to cryptography then covers the many subtle mistakes that even experienced developers make when writing cryptographic code.

Attendees will learn about proper implementation of the Java Cryptography Extension, Java Secure Sockets Extension, and jarsigner. Special attention is given to the challenges of key management and Public Key Infrastructure. No prior knowledge of cryptography is necessary.

By Roman Hustad
This session examines the code that developers must write in order to enable the detection of malicious activity and preservation of evidence after a security breach.



There are only two kinds of software applications: those that have been hacked, and those that will be hacked. Since it is only a matter of time before an incident occurs, take action now to make sure you find out before the Wall Street Journal does. Key components of your strategy should include tamper-proof audit trails, appropriate log events (some might surprise you!), and regular monitoring. Because hackers know they need to cover their tracks, specific attacks against logging mechanisms are also covered.

By Ryan Breidenbach
In 2006, Spring 2.0 was released and Spring became ubiquitous in the enterprise Java space. So if you haven't taken a peek at Spring yet, what are you waiting for?!? If the answer is "This session," you have come to the right place. This session will familiarize you with the benefits Spring provides and why they have made the framework so successful. In addition, we will focus on the efforts that went into Spring 2.0 to make these benefits much more developer friendly. By the end of this session, you should have a grasp of how Spring 2.0 simplifies the utilization of Spring's core features such as bean wiring, AOP, and the simplification of using enterprise Java. If your head is not spinning too much.

In this session we will cover:
- Brief history of Spring
- Overview of Spring's core values and features
- New Spring 2.0 features
- Glimpse of upcoming Spring 2.1 features

By Ryan Breidenbach
Although Spring's rise to ubiquity was driven by its IoC and AOP services, it offers so much more. One of the most powerful of these services is Spring's MVC framework.

If you are familiar with other Java web frameworks such as Struts or WebWork, you will recognize that Spring MVC is a similar request-response web framework driven by a Front Controller, in this case the DispatcherServlet. But Spring also provides considerable functionality out of the box. One of the beauties of the Spring MVC is that, like the rest of Spring, all of its components are quite modular. This allows you to mix and match different implementations of the various MVC components as you see fit for you application.

In addition, Spring MVC provides rich capabilities for data binding. This allows you to transparently bind form parameters to your application objects without having to create any intermediate objects. Spring's validation features allow you to capture both binding and application errors. And with Spring 2.0's much improved JSP tag library, both creating forms and displaying validation errors is quite simple.

In this session we will cover:
- A quick overview of Spring for first time Spring users
- Configuring Spring's DispatcherServlet
- Wiring other application beans to web application beans
- Mapping requests to Spring Controllers
- Spring's different Controller implementations, and when they should be used
- Validation form parameters and binding them to application objects
- Creating forms using Spring's custom JSP tags library

By Ryan Breidenbach
2006 appeared to be the year that Maven achieved the momentum it needed to overtake Ant as the build tool of choice for Java developers. A lot of that has to do with the vastly improved Maven 2. But it lot of it has to do with the simplicity, organization and power that Maven brings to projects. The session will bring developers new to Maven with everything it has to offer. This includes creating your very first Maven project, learning the significance of the POM file, how to let Maven and its repositories manage your dependencies, and how to let Maven report of the health of your own projects. And for the Ant users in the audience, you will get to see a side-by-side comparison of the two build tools' build philosophies.

In this session we will cover:
- Fundamental differences between Ant and Maven
- Maven fundamentals: the POM file and Maven repositories
- Dependency management
- Creating a build artifact using Maven
- Filtering application resources
- Migrating from Ant to Maven