Spring and Hibernate in the Middle Tier 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.

AOP and JMX: A Match Made in heaven by Ben Hale
You're winding down 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 JMX, you can introduce amazing management and monitoring capabilities without changing you're 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.

Spring 2.0: New and Noteworthy 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.

Spring Web Flow Jumpstart by Ben Hale
Have you ever developed a web application with a long user action based on form input? Did you curse the Java community for their inability to address this very common application type? Well, attend this session about Spring Web Flow and you'll curse no more.

In this session we'll learn about a new(ish) Spring sub-project, Spring Web Flow. Spring Web Flow is an innovative new framework for declaratively modeling web application user interactions. We'll start with an exploration of some web development issues and then take a look at the value proposition that Web Flow brings to the table. Once everyone is comfortable with that, we'll jump straight to code. We'll start by exploring some of the features that SWF has and then we'll finish with a live coding example where the audience will help write the application.

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

Applied AOP 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.

Give it a REST 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.

NetKernal: XML Processing for the 21st Century by Brian Sletten
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. Imagine the simplicity of REST married to the power of Unix pipes. Come see how this open source / commercial product built on a compelling modern architecture can be used to create, manipulate and transform XML.

Domain Driven Development using Naked Objects 3.0 by Dan Haywood
Are you using Hibernate or EJB3 in your application? If so then you probably believe that putting a domain object model in the center of your application is worthwhile. But just how good is that domain object model ... how well does it capture the complexity of the domain in question? A domain expert can tell us, of course, but to get their views we need a way to show the domain model to them.

RAD JSF with Seam, Facelets, and AjaxJSF, Part One 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.

RAD JSF with Seam, Facelets, and AjaxJSF, Part Two by David Geary
A continuation of a 2-session presentation on Seam, Facelets, and Ajax4jsf.

The Google Web Toolkit, Part One 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.

The Google Web Toolkit, Part Two by David Geary
The second part of a 2-session presentation on the Google Web Toolkit.

Agile Immersion by David Hussman
Have you heard about SCRUM or XP but never done it? If you want to give it a try, this session will allow you to participate in planning and executing several agile iterations. A working knowledge of either XP or SCRUM will be helpful but not mandatory.

Getting Agile Planning and Tracking Up and Running by David Hussman
If your company is using agile or thinking about it, this session will show you how to plan and tracking an agile project. Examples projects will be discussed, including the glory and horrors. Various planning tools that help distributed teams will be presented as well as a collection of lo-fi tools which truly help find and address the issue that plagues so many projects: “when are we going to complete this project”.

Creating Agile Requirements by David Hussman
Successful project communities balance written requirements with a healthy amount of discussion. This is at the core of requirements that could be deemed “agile”. Many agile projects choose to use user stories, but others may be using use cases or other forms of written requirements. This session is for anyone wanting to improve their requirements, including the creation of good requirement and the presentation styles that help people focus on creating great software products, and stop focusing on documents.

Coaching Agile Projects: Finding your Groove by David Hussman
Is someone asking you to lead an agile project? There are many ?how to be agile? books, but the coverage of skills and techniques for leading are a bit on the light side. Whether you are a manager, tech lead, or a non-stop inspiration for your fellow developers, this session will provide you with new insights into the how and whys associated with coaching / leading an agile project or an agile transition.

Executable Documentation by David Hussman
Why is so much documentation worthless? Wouldn’t is be nice if your documentation actually reflected what your system does? One way to do this is through is by creating “executable documentation. If you are struggling with ambiguous requirements, lack of contact with the business, or a chasm between development and testing, this session is for you.

Application Security: Part 1: Stop the Bleeding by Dean H. Saxe
This session is geared for those who are ready to take the first steps towards securing their applications with minimal cost and effort. Most development teams know that they have not given security the attention it deserves, but also don't know where to begin. Should you run a scanning tool, go to security training, or just bury your head in the sand and pretend everything is OK?

A few simple activities are introduced that will pay big dividends for the security of your applications. One size does NOT fit all, and this session will enable you to spend your time and money where it will make the most difference. Peripheral issues are also addressed, such as obtaining management support and working with your IT security department.

Application Security: Part 2: Building a Software Security Program by Dean H. Saxe
This session provides a comprehensive, flexible plan for baking security into the software development lifecycle. First off, we will talk about why you would want to do such a thing and how to get support for it. Then the discussion will turn to the practical aspects of planning and implementing a secure SDLC, covering all aspects of people, process, and technology.

Last and probably most important, we present ideas to help you avoid having your shiny new program ignored by the development team. If you are serious about producing secure software, this talk is for you.

How to Do a Security Code Review by Dean H. Saxe
This session is a hand-on exercise in Java code review that will cover both manual and automated techniques. If you envision code review as a line-by-line slog through thousands of programs, you will be surprised to learn some effective techniques that reduce the tedium and increase your enjoyment of this activity (well, maybe not the enjoyment part). Familiar methods such as pair programming and peer reviews are a great place to start and will immediately increase the security of your code base.

Other approaches will also be examined, ranging from the use of IDE-integrated tools to formal code review exercises and everything in between. In particular, threat modeling is presented as a means to identify sections of the code that have the highest security risks. Enforcing a code review policy is the last (and most contentious) topic that will be covered in this session.

What You Don't Know About Cryptography by Dean H. Saxe
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.

TDD, Take 2 by Erik Doernenburg
More and more developers are being drawn to Test Driven Development (TDD). It doesn’t take much time or effort to get going, especially after you have passed that first hurdle of approaching development using the mantra of “red-green-refactor” instead of “code for days and then debug and test”. But after a while you discover that TDD has more to it than just basic state-based testing. In this session Erik will present in-depth discussions of topics such as interaction-based testing, dependency injection, classical vs mockist testing, test doubles, and the object mother pattern.

Cutting-edge productivity with RIFE by Geert Bevin
RIFE is a full-stack, open-source Java web application framework, offering fast results with the promise of maintainability and code clarity. This session will review the novel ideas in Java web application development that RIFE has introduced to the development community.

Exploring Terracotta : JVM clustering in the real world by Geert Bevin
Terracotta provides open-source clustering for Java and removes the burden from the developer. Instead of having to design and code against a specific API, the characteristics of the Java Memory Model (wait, lock, notify) are automatically translated towards a multiple node architecture. This clustering solution guarantees proper handling of concurrency, fail-over, distributed method invocation and efficient state propagation by simply instrumenting your Java bytecode and providing you with Network Attached Memory. This is however so generic that it's sometimes difficult realize which use-cases can benefit from it.

This presentation introduces the basic principles of Terracotta and explains how to configure and integrate it into your application. Afterwards, we'll go through a collection of real-world examples that all benefit from JVM-level clustering. These include: serialization-less HTTP session clustering, fine-grained distributed caches, workload distribution through master-worker, shared state and events between server and desktop tiers, clustered Spring and other OSS frameworks ... and more.

Garbage collection made the JVM responsible for memory management. Take the plunge and experience how Terracotta does the same for clustering.

GORM - Object Relational Mapping with Hibernate De-mystified by Graeme Rocher
Hibernate is an immensely powerful ORM layer with an array of features and mapping options which comes at the cost of complexity. The web application framework Grails ships with an ORM layer that builds of top of Hibernate, but eliminates much of the complexity through clever use of convention and the dynamic features of the Groovy language. Known as GORM, it offers a convention-based mapping strategy that hooks into the Hibernate configuration model and provides an abstraction layer above Hibernate with powerful features like Groovy builders for Criteria, dynamic finders and transaction management through closures.

The Grails Plug-In System: Plug into Productivity by Graeme Rocher
Grails is more than just a web framework, it is a complete platform and API for runtime configuration. This talk, by Grails project lead Graeme Rocher, will demonstrate Grails' modular architecture and how to hook into runtime configuration to adapt your application based on its environment and/or the presence of other plug-ins.

Grails: Spring & Hibernate Development Re-invented by Graeme Rocher
Spring & Hibernate development, although hailed in the past as being "lightweight", is still an XML-centric, configuration heavy approach to web application development. In this talk, by Grails project lead Graeme Rocher, you will discover how you can leverage Spring & Hibernate without ever having to write a line of configuration!

Advanced Web Application Security by Joe Walker
The security landscape has changed dramatically in the past 12 months. Unless you are aware of CSRF, Javascript Highjacking, and the many ways to fool an XSS filter, it's likely that your web application will not be secure. Attackers used to concentrate on ActiveX, but now Javascript, CSS and even simple HTML elements have are used against websites.

Hands On DWR by Joe Walker
This presentation digs into many advanced DWR features such as Reverse Ajax and the JavaScript proxy APIs. We start with a simple web-based multiplayer game, and illustrate how straightforward it is to create advanced effects with minimal coding. By demonstrating advanced page manipulation and server-based control of browsers, the game shows how to update any web application to react to server changes.

Flooring the flaws: The top ten bottomed out by Mark Goodwin
Research shows that over 80% of web applications are at risk of attack due to serious security issues. This session takes a look at the ten most serious vulnerabilities (as defined by OWASP), the anantomy of common attacks and techniques for mitigation. If you're not into web stuff please don't be put off; all three of the top ten are applicable to almost all software systems.

Raising the game: Top ten techniques for secure design by Mark Goodwin
Want your software to be secure but don't know where to start? You're not alone. Learn about black, grey and white box security testing. Review your code for broken access control, code injection, and other hacks; and integrate security considerations into product development lifecycle.

10 Ways to Improve Your Code by Neal Ford
No one writes perfect code, and every developer eventually falls into a slump where they just crank out the same code day after day. This session illustrates 10 different ways to improve your code, covering sacred cows, good citizens, smells, and more.

Implementing SOA 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.

Metrics-driven Agile Development by Neal Ford
Agile software development is a highly disciplined way to build software, and one of the side effects of this discipline is the ability to gather meaningful metrics. This session describes what makes agility perfectly suited to metrics gathering and what kinds of real-world metrics you can generate.

Building DSLs in Static and Dynamic Languages 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.

Introduction to JRuby 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.

Rails for JRuby 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.

Power Regular Expressions in Java by Neal Ford
Regular expressions should be an integral part of every developer’s toolbox, but most don’t realize how important 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.

Pragmatic Extreme Programming by Neal Ford
This session talks about how to actually get XP done in the real world (and what to tell your boss). This session includes artifacts (like project tracking sheets) from real XP projects.

Building a lightweight ESB with Apache Synapse by Paul Fremantle
Paul, a committer and release manager on the project, will show how Synapse works and what can you do with it. One of the main areas of interest in Apache Synapse is for users to build an Enterprise Service Bus (ESB). In this session, we will define the concept of an ESB and look at how to build a pragmatic ESB that allows you to manage, connect and transform service interactions. In particular, Paul will look at the most common patterns: virtualization, logging, transformation, fault-handling, and versioning. The session will be based on simple code examples and configuration models. Attendees should have some experience of XML.

Apache Axis2 for Developers by Paul Fremantle
Apache Axis2 is a framework for Web Services that supports SOAP and XML/HTTP interactions, as well as enhanced standards such as ReliableMessaging and Security. In this session, Paul will show how developers can get started with Axis2 and easily create and consume remotely-accessible services. Paul will show how to deploy and run POJOs as services, and how to simply create clients to services. Paul will look at common debug and trace approaches, as well as how to configure common aspects, such as the use of HTTP proxies. In addition, the session will look at how security and reliability can fit into the Axis2 framework to provide an enhance quality of service.

Ajax Development with the Yahoo! UI Library and Grails by Scott Davis
Yahoo! is a company that eats its own dog food. They open sourced the Ajax code that drives many of their own websites, including their eponymous homepage, Yahoo! Mail, and Yahoo! News. Come see first hand how the various pieces of the library work together as a seamless whole.

Groovy and Java: The Integration Story 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.

GIS for Web Developers by Scott Davis
Based on the book GIS for Web Developers, this talk demonstrates how you can build your own Google Maps in-house using nothing but open source software. We also discuss integrating free, public domain data from sources like the US Census Bureau and the USGS. If you're looking for real-world examples of AJAX in use, you'll find it here. If you're looking for real-world examples of web services in use, you'll find it here.

Groovy: Greasing the Wheels of Java 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.

KEYNOTE: No, I Won't Tell You Which Web Framework to Use: or The Truth (with Jokes) 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..."

Enterprise Performance and Scalability by Ted Neward
Wondering why your enterprise Java app just? sucks? Trying to figure out why you can?t get more than 10 concurrent users online at the same time? Looking for ways to try and spot the slowdowns and ways to fix them?

The Busy Java Developer's Guide to Debugging and Monitoring by Ted Neward
Bugs? We all know your code has no bugs, but someday, you're going to find yourself tracking down a bug in somebody else's code, and that's when it's going to be helpful to make use of the wealth of tools that the Java Standard Platform makes available to you--tools that your IDE may not know exist, tools that you can make use of even within a production environment.

The Busy Java Developer's Guide to Threads and Synchronization 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.

The Busy Java Developer's Guide to java.util.concurrent 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.

The Busy Developer's Guide to Rules and Rules Engines Using JESS by Ted Neward
If you've been keeping your ear to the ground, you may have heard some talk recently about "rules", "business rules" and "rules engines", but not necessarily any clear discussion on what they are, how to use or design them, or why they might be useful or important.

Practices of an Agile Developer by Venkat Subramaniam
You have worked on software projects with varying degree of success. What were the reasons for the success of your last project? What were the reasons for those that failed? A number of issues contribute to project success - some non-technical in nature. In this presentation the speaker will share with you practices in a number of areas including coding, developer attitude, debugging, and feedback. The discussions are based on the book with the same title as the talk.

Annotation Hammer by Venkat Subramaniam
Annotation is an interesting feature in Java.
However, like any features, there are good uses and bad uses.
When should you use Annotation? This presentation will answer that question for you.

OSGi: A Well Kept Secret by Venkat Subramaniam
In this presentation we will introduce OSGi and discuss how it can help modularize and version your enterprise Java applications.

Spring into Groovy by Venkat Subramaniam
What do you get when you mix an agile, object-oriented, dynamic language with a lightweight, flexible, and extensible framework? You get a Groovier Spring. Spring allows you to develop using Groovy as much as Java. Groovy brings some neat concepts to the Java Platform that is hard to realize directly through the Java language. Using these capabilities can lead to elegant and easier Spring development.

Drooling with Groovy and Rules by Venkat Subramaniam
Rule based programming allows us to develop applications using declarative rules. These can simplify development in applications where such rules based knowledge is used for decision making.

Java 6 Features, what's in it for you? by Venkat Subramaniam
What benefit do new Java 6 features offer you. Are there issues with using these features. The objective of this presentation is not simply to introduce you to the features, but to the effective use of these as well.

Open Source Tools for Agile Development by Venkat Subramaniam
As a Java developer, you have taken the time to learn the basics of the language and relevant parts of its rich API. However, you need more than that to develop serious industrial strength applications. In this presentation, the speaker will introduce you to a number of open source tools which you can use to improve your application quality and your development process.

Programming with Mock Objects by Venkat Subramaniam
You are convinced that Test Driven Development is good for you and your project. You realize the benefits it has to offer. What's holding you back? All the code and components that your code so heavily depends on is most likely making you wonder if TDD is really for you. We will start out by looking at dependency and dependency inversion. Then we will discuss how mock objects can help separate our code from its dependencies.

get FIT by Venkat Subramaniam
Unit testing tells you, the programmer, that your code (and the change) meets your expectations. How do you know if you are meeting your customers' expectations? Agile development is all about feedback and doing what's relevant to the customers, isn't it? Framework for Integration testing or Fit helps you to automate tests for customer expectations.