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

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

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

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

Note: This is a companion talk to my other talk, Productive Programmer: Automation and Canonicality, but each talk is completely independent of the other -- they are not "Part 1" and "Part 2".

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

<cite>Note: This is a companion talk to my other talk, <b>Productive Programmer: Acceleration, Focus, and Indirection</b>, but each talk is completely independent of the other -- they are not "Part 1" and "Part 2".</cite>

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

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

As out applications have spilled from the server across the wire to the web tier, we increasingly must debug and test in the browser. This session covers debugging and testing tools for clients, JavaScript, and Ajax.

As the browser has become important again, our applications have spilled out of the server side to the web tier, and now we have to debug and test there. This session is all about debugging and testing the web tier. I discuss the tools Firebug, Venkman, the Developer's toolbar, and bookmarklets for debugging JavaScript, Ajax, and general browser behavior. Then, I discuss testing the web tier, first with unit testing via JsUnit, the user acceptance testing with Selenium and Sahi. This session is packed with examples and demonstrations, including real-world scenarios and pitfalls.

Session Topics:

• Debugging
• Firebug
• Venkman
• Developer's Toolbar
• Bookmarklets
• Testing
• JsUnit
• Selenium
• Sahi

By Neal Ford

This session discusses advanced Selenium techniques for testing web applications. It discusses techniques for both TestRunner and Remote Control Selenium, including data driven tests, creating branch points, testing Ajax applications, creating flexible tests, integration with continuous integration, and tons more.

By now, just about everyone has heard of Selenium, the revolutionary open source testing tool for web applications. This session takes Selenium to the next level, showing how to handle complex, real world scenarios in Selenium. It discusses Selenium setup for both TestRunner and Remote Control. Mostly, though, this session delves into specific techniques for testing real world kinds of behaviors in web applications. I discuss data driven tests, generated tests, decision points in tests, interactive Remote Control, integration with continuous integration, testing Ajax applications (including applications that only Selenium can test), and future directions. This session will turn up the volume on your testing to "11".

Session Topics:

• Generating random values
• Data-driven tests
• Remote control Selenium
• Setup
• Interactive mode
• Writing and running tests
• Decisions, decisions
• Test Reusability
• Integration with continuous integration
• Documenting tests
• Choosing the right mode for the job
• Extending Selenium
• Testing Ajax applications
• Testing data
• Testing dynamic user interface
• Specialized Selenium
• Future directions

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?

In this talk, we'll look at the various things that can occur in an enterprise Java app (from the smallest web site to the largest multi-resource environment) to make your Java apps perform and scale less well than they should, and how you can work to correct them. We'll examine a variety of broad concepts to apply in architecture and design, and examine what factors make an enterprise application slow, then use a variety of tools to figure out how to remedy them.

By Ted Neward

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

For an intermediate Java audience.

By Ted Neward

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

For an intermediate-level audience.

By Ted Neward

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

For a beginning to intermediate Java audience.

By Ted Neward

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 have some basic ideas about bug-tracking in your toolbox. Learn 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.

Learn to use jdb, jconsole, jps, jstat, and other tools to identify and squash software defects that just won't reveal themselves during development. Then, just in case those tools aren't enough for you, we'll look at how to write your own, special-purpose tools using the same technology backplane.

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 Brian Sletten

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

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

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

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

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

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

By Brian Sletten

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

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

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

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

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

By Brian Sletten

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

We will take a close look at a number of features that you will be expected to know well when you program using Java 6.

By Venkat Subramaniam

In this presentation we will introduce OSGi and discuss how it can help modularize and version your enterprise Java applications.

In this session we will delve into: What is OSGi? OSGi fundamentals Modularization and versioning Developing and deploying components OSGi implementations OSGi and Spring integration

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.

In this presentation we will learn how to write Fit tests and how to automate their execution. We will also use FitNesse.

Topics: Beyond Unit Testing Integration Testing Customer Expectations Writing Fit Tests Writing Fixtures Automating tests What is FitNesse Using FitNesse

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.

In this presentation we will cover topics including: Strengths of Groovy Using Groovy in Spring Configuration Bean Development Deployment How it fits in

By Venkat Subramaniam

Domain Specific Languages or DSLs are languages that target a specfic kind of problem or domain. We've had various degree of success with DSLs, over the past several years, in narrow areas. However, DSLs are not widely used in general purpose application partly because the popular widely used languages today do not make it easy.

In this presentation we will introduce DSLs, delve into their benefits. We will look at a number of examples as to how we can utilize them for common application tasks. We will take a look at what language developments, tools, and techniques are in the horizon that could bring this to common place.

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.

In this presentation we will take a look at Drools and its evolution into JBoss Rules and how you can express rules including Groovy and other alternatives. We'll taken an example oriented approach to creating a sample application.

By Venkat Subramaniam

Most interest around Functional Programming (FP) has been academic until recently. Recent commercial languages are beginning to exploit FP features. Knowing more about FP will not only help us make better use of these features, but to exploit those. In this session we will take a close look at FP.

What is FP? Strength and weakness of FP FP languages for Java programmers Examples that you can use today Thinking in FP

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 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

How many times have you started a new project only to find that several months into it, you have a big ball of code you have to plod through to try to get anything done? How many times have you been the ?new guy? on an established project where it seems like the code grew more like weeds and brambles than a well-tended garden? With a few good structural guidelines and several tools to help analyze the code, we can keep our project from turning into that big ball of mud, and we can salvage a project that is already headed down that path.

This talk will talk about everything from build processes, teamwork, and project structure through versioning, release plans, upgrde strategies, package dependencies, and more. Using real-world scenarios from two projects with 12-15 people working together over a 5-year time span, this presentation will offer advice based on multiple successful deliveries of real software.

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

GORM (the Grails Object/Relational Mapper) is one of the many high points of the Grails web framework. GORM is a thin Groovy wrapper over Hibernate, but that doesn't begin to capture excitement of what GORM brings to the party. Imagine being able to call book.save() and book.delete() on your Book class; calling Book.get(1) to retrieve your book from the database by primary key; using Book.list() to pull an ArrayList of Book objects into your application. Now imagine getting all of that functionality (and more) for free with each new class you define. No interfaces to implement. No abstract classes to extend. Persistence that is transparent, automatic, and simple to use: GORM.

Querying your data via GORM is a case study in the benefits of using a dynamic language. Queries like Book.findByAuthorAndTitle("Scott Davis", "Groovy Recipes") rule the day. For the really hard stuff, you can always get back to a more traditional SQL-based interface. We'll also explore Query-By-Example.

GORM allows you to model your objects in the database in a variety of ways. In addition to supporting the usual 1:M, 1:1, and M:M relationships, GORM allows you to flatten the model, breaking traditional normalization rules. (Just don't tell your DBAs about it...) Come see how GORM handles HashMaps, Arrays, and ArrayLists in your Groovy objects.

GORM can auto-generate your database schema from existing POGOs, but recognizes that not all development is greenfield development. GORM allows you to map existing tables to objects and arbitrary field names to POGO attributes. We'll also see how to bypass Hibernate altogether using EJB3 annotations.

If you are a Hibernate developer, you owe it to yourself to see how GORM makes a good thing even better. If you are a Groovy/Grails developer, come see how to get the most of your friendly neighborhood persistence framework.

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.

We'll look at some of the everyday useful widgets like the onscreen JavaScript logger (which effectively brings Log4J-style logging to JavaScript) and the calendar components. We'll see how event handling is managed in a cross-brower fashion. We'll look at tabbed interfaces, multi-level menus, and panels and dialog boxes that end up making your website look more like a OS-level desktop than a traditional webpage.

The YUI library is included with the Grails web framework. It certainly works in all of the major frameworks as well, but the easy bootstrapping of Grails combined with the power of YUI library makes for the quickest way to get started with a minimum of hassle. No previous Groovy or Grails experience is required, so come to learn a little about all of these. Any experience JEE developer will feel right at home since Grails uses Spring and Hibernate under the covers.

By Mark Fisher

Spring Security (formerly known as 'Acegi') enables self-contained, consistent, and extensible solutions for securing your applications. Version 2.0 provides major enhancements including a domain-specific XML namespace, convention-based defaulting, and annotation support. This provides a significantly simpler experience for developers while still supporting the same degree of flexibility.

Spring Security's interceptor-based approach is non-invasive even when extended to accommodate domain-specific requirements. The two main security processes (authentication and authorization) are decoupled in order to provide flexibility across a wide variety of providers and strategies. This presentation will include an overview of Spring Security's pluggable authentication process and how it accommodates a wide range of possibilities including Database, LDAP, Single Sign On, and even an in-memory option for development and testing. We will then proceed to cover authorization where you will see its consistent approach for securing web requests and method invocations. Throughout the session, we will walk through a sample application that demonstrates Spring Security's core features.

By Mark Fisher

An Enterprise Service Bus (ESB) brings flow-related functionality such as message routing and transformation to a Service-Oriented Architecture. An ESB also provides a layer of abstraction with endpoints for various protocols and transports. These features promote decoupling of integration logic from business functions, flexibility in the transport layer, and pluggability of POJO services.

While ESB is a vast topic, this session will offer a glimpse of a few technologies (scheduling, messaging, and remoting) within the context of an ESB. The content will be heavily example-based with a good deal of code and configuration. The emphasis will be on Spring's enabling role for implementing POJO-based solutions that achieve flexibility in the face of the constantly changing requirements of enterprise integration.

By Mark Fisher

Spring 2.0 introduced support for Message-Driven POJOs meaning that it is now possible to receive JMS messages asynchronously and delegate the handling of those messages to simple objects even within a lightweight application running outside of any application server. If your POJO has a return value, it will automatically be sent to a response destination.

After a quick overview of Spring's JMS support, we will build a Message-Driven POJO sample application from the ground up. This will include sending a Message as a request and receiving a reply across separate JVMs. You will learn how to configure the Message-Driven POJO without writing a single line of messaging code. You will also learn how to configure the pool of concurrent consumers and integrate with Spring's transaction management. We will use the JMS namespace available as of Spring 2.5, and we will even explore the possibility of delegating to a Groovy-scripted object.

By Andrew Glover

Behavior-driven development, or BDD, has attracted a lot of attention a la RSpec in the Ruby community, but BDD's roots stem from JBehave, a Java based framework. In this session, we'll look at what BDD is and how it shifts the traditional testing vocabulary from being test-based to behavior-based.

Behavior-driven development, or BDD, has attracted a lot of attention a la RSpec in the Ruby community, but BDD's roots stem from JBehave, a Java based framework. In this session, we'll look at what BDD is and how it shifts the traditional testing vocabulary from being test-based to behavior-based.

By Andrew Glover

The practice of continuous integration facilitates early visibility into the development process by regularly conducting software builds, thus integrating disparate software pieces earlier than later, which often times minimizes the interval between when a defect is coded and when it is discovered. Given the automated nature of continuous integration spawned builds, software teams can now start to look at their build process as something more useful than a simple compile and test process.

The practice of continuous integration facilitates early visibility into the development process by regularly conducting software builds, thus integrating disparate software pieces earlier than later, which often times minimizes the interval between when a defect is coded and when it is discovered. Given the automated nature of continuous integration spawned builds, software teams can now start to look at their build process as something more useful than a simple compile and test process. Builds can be augmented with a series of Software Inspectors, which report on various aspects of software quality, such as code complexity, code duplication and code dependences to name a few. In this presentation, attendees will learn about the practice of continuous integration and the available CI tools for Java. Furthermore, Software Inspectors will be examined and attendees will learn how to interpret the data they provide and how to take actionable items based upon that data.

By Andrew Glover

Are your Ant builds giant XML files that scream for attention? Why not enhance your build process to act like a quality gate, much like a test suite would?

Are your Ant builds giant XML files that scream for attention? Why not enhance your build process to act like a quality gate, much like a test suite would? In this session, we'll look at managing 3rd party dependencies with Ivy and then add the power of Groovy to script in quality checks, such as monitoring complexity; plus, we'll look at how to create a customizable dashboard via Groovy.

By Andrew Glover

It has been said that Grails is the addiction and Groovy is the drug. If you want to start building slick web applications rapidly with Grails it helps to start with a solid understanding of the Groovy language itself.

It has been said that Grails is the addiction and Groovy is the drug. If you want to start building slick web applications rapidly with Grails it helps to start with a solid understanding of the Groovy language itself. In this session, we'll go over the basics of the language by focusing on the core of Groovy. We'll look at Groovy collections, Groovy's interaction with Java, creating Classes in Groovy, Groovy's MOP and much much more. By the end, you'll be a Groovy expert ready to embrace all the language has to offer.

By Jason Harwig

JavaScript's popularity in recent years has brought with it the attention of hackers, white and black. Both sides looking for ways to do things that weren't intended with the scripting language.

In this talk we'll look at the more popular, but also some of the interesting JavaScript security issues that could effect your applications or users. We'll use Digg.com to introduce CSRF as a case study.

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.

The session will focus on finding the people who are best suited to create and communicate agile requirements. We will examine how to ensure agility for user stories, use cases, and several other common forms of requirements. Without regard to the document type, we will show how to smoke out what needs to be captured in written form when, challenging the age old notion that more detail in requirements produces better software.

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".

From using markers and post it notes to go faster tools, this session will examine ways to get agile going in various situations (e.g. small projects, large projects, or distributed projects). A variety of techniques and tools will be shown and discussed along with the pros and cons of each. Most importantly, you will come away with a variety of ways to start planning and tracking agile projects, so you can choose a path which fits best within your company.

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 to create what is being called executable documentation or executable specifications. 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.

What is executable documentation? Simply put, instead of adding more details to requirements, capture the desired system behavior in acceptance testing tools which are accessible to the entire project community. The session will focus on FIT, but it may include other tools for creating ED. History has shown me that ED - requirements that have two states (green and red) - helps project communities consistently create better software, faster!

By David Hussman

Although there are many books about agile, but few provide a path for guiding you through the beginning of an agile project. Whether you are preparing for your first agile project, or taking the lead for the first time, this session will provide a guided tour filled with practical advice and a pile of anecdotes.

We will start with things to do to prepare for the first iteration: assessments, project chartering, setting up a lab, iteration 0 and creating your first backlog. From there we will move into coaching practices like fostering discussions, facilitating retrospectives, social radiators, developer manifestos, talking in tests, and more. These are the techniques that will help you lead and successfully guide a newly forming agile community.

By David Hussman

Once your agile project is rolling along, there are many bumps and roadblocks which can derail the train. Whether you are leading the project formally or informally, there are techniques you can use to keep the project alive and innovative. This session will cover skills and techniques for leading sustainable project communities.

We will walk through some basics which need to be in place and then we will move on to advance topics like maintaining a living backlog, adapting to change, growing meaningful metrics, radiating information, working with project members, anti-coaching and more. We will also discuss a collection of monitors (spontaneous pairing, ?us? and ?them?, presence of pride, emergence of leaders) used by working coaches to determine which practices to use.

Prerequisite: Leading Agile Projects: Finding Your Groove in the First 4 Iterations

By Mark Johnson

Validate that requirements are not missed during the design and development process by creating Requirements document test fixtures to clarify and validate the requirements between the end users, business analysts, architects, and developers early in the project.

The requirements test fixtures are then available throughout the project to validate that the implemented product is the same as documented requirements. Using RDDD can significantly reduce software development projects project duration, improve communication between all stakeholders, improve delivered quality, and customer satisfaction.

By Mark Johnson

Once you leave academic "hello world" projects, software development is full of unknowns which result in the high rate of project failure we see too often in industry. Reasons for a project failure will vary based on the stakeholder interviewed. This session will provide a software development risk framework and examples you can apply in your projects to reduce or at least soften the impact of failure.

The Software Development Risk Analysis techniques presentation examines several tools taken from the Six Sigma world to identify and manage risks with the objective to avoid failures or at least soften the impact of failure. Because software development is a team exercise this presentation is targeted towards everyone from Software Development managers to hands on developers. During the presentation we will apply risk management techniques to several sample (and typical) software development project problem areas.

By Ramnivas Laddad

This session (part 1 of the two-part session) shows the core concepts in the Spring Framework -- the most popular lightweight container that recently crossed 1 million downloads.

In this session we discuss the need for the Spring way of creating enterprise application. We cover the core ideas such as beans, dependency injection, container configuration, proxy-based AOP, and portable abstraction layer. By the end of this session, you will have a clear idea on what Spring is and what it can do for you.

By Ramnivas Laddad

This session (the second part of the 2-part session) will cover advanced concepts in the Spring framework. While the core concepts in the first session will get you started with Spring, the advanced concepts in this session will make you effective at developing Spring-based applications.

In this session, we will cover advanced concepts such as factory bean, proxy bean, and factory method. We will also cover effective ways to test your Spring applications as well as extend Spring to meet your special requirements. We will do live coding to explain many concepts. By the end of this session, you will be ready to start using Spring (or if you have already started, be effective with it).

By Ramnivas Laddad

If you are keeping up-to-date with all the cool features in Spring 2.0, you have surely heard about much improved integration with AspectJ. AspectJ is for real. Come to this session to understand the core concepts of this wonderful technology and how to use it to create even simpler Spring-based applications.

This talk will introduce AspectJ to developers experienced with Spring and explain core AspectJ constructs. The talk will show several simple examples to reinforce the concepts learned.

By Ramnivas Laddad

Specifying metadata using annotations has gained huge popularity since its introduction in Java 5. However, the story on consuming annotations isn't as clear. Reading and processing annotation is still a complex process often requiring you to understand byte-code manipulation tools and their low-level API. As a result, most developers shy away from using custom annotations, limiting their usages of annotations only those prescribed by frameworks. The result is missed opportunities for programming simplification. In this session, we explore how AOP can make it a simple task to consume annotation in a powerful manner.

This session explores many opportunities to consume annotations using Spring AOP and AspectJ. The examples discussed in this session cover a wide range from auditing, monitoring to security, transaction management, and policy enforcement. It also examines best practices in using annotations to avoid pre-processor like use of them.

By Scott Leberknight

This session introduces the Hibernate Object/Relational Mapping (ORM) framework, showing the basics of persisting Java objects to relational databases. No prior knowledge of Hibernate or ORM is assumed.

Persistence is a key element of most applications, whether web or desktop. Relational databases are the defacto standard for enterprise data storage and object-oriented (OO) programming, for example in Java, is the predominant technique to build applications today. Relational databases and OO, however, are completely different paradigms. Object/Relational Mapping (ORM) seeks to bridge this gap to allow easy persistence of objects to relational databases. Hibernate is a leading ORM framework providing persistence of Java objects to relational databases. This session introduces Hibernate and covers ORM alternatives available today; getting started with Hibernate; mapping objects to database structures; interacting with Hibernate APIs to find and persist objects; transactions; and finally, architectural considerations and suggestions for integrating Hibernate into applications.

By Scott Leberknight

Spring's Hibernate integration simplifies applications that use Hibernate by removing tedious and repetitive infrastructure code that you need to write. Spring JDBC achieves a similiar simplification for executing SQL statements using the lower level JDBC API. So when do you use one or the other, and what are the important usage guidelines? Come to this session to find out.

In this session you will learn best practices and tradeoffs when using Hibernate with Spring. We will consider Hibernate session factory configuration, DAO and business service implementation, declarative transaction management, unit and integration testing, and dealing with Hibernate lazy-loading.

In addition, you will learn how to combine use of Hibernate with use of JDBC in the same application and the cases for when that is appropriate.

By Kito Mann

This session examines the ecosystem of products built on JavaServer Faces.

We start with a discussion of why JSF is significant and explain how it lays the foundation for a range of new products. We then look at the IDE offerings from major industry players, such as Sun, IBM, and Oracle. Next, we examine the products from smaller vendors and open source organizations, such as component suites and additional toolkits and frameworks, examining the specific features and benefits that these products provide. Finally, we look at other potential product opportunities and examine ways to get involved.

Prerequisite: Basic familiarity with web application development in Java.

By Kito Mann

With the emergence of AJAX as a preferred way of building web user interfaces, JavaServer Faces (JSF) has proved itself to be a natural fit for integrating AJAX with Java sever-side logic.

JSF allows you to build AJAX applications without worrying about the complexities of JavaScript and DHTML. However, many different approaches for using AJAX with JSF have emerged. This session looks at these different approaches, the pros and cons, and provides key insight into JSF's future as an AJAX web development platform.

By Kito Mann

JBoss Seam is a popular open-source application framework for Java Platform, Enterprise Edition (Java EE) 5.0. For web application developers, a significant benefit of Seam is that it greatly enhances JavaServer Faces technology. This session explains key Seam features such as tight integration with EJB3, Hibernate and JPA integration, conversations, RESTful web pages, and so on.

This presentation introduces Seam web features from the perspective of a developer on the JavaServer Faces platform. It uses a lot of code examples and demonstrates live applications. It also discusses RAD tools for getting a Seam JavaServer Faces technology-based project started. Developers attending this presentation will leave with a basic understanding of exactly what Seam is, what problems it solves, and how to get started.

Prerequisite: Basic understanding of Java web application development. Familiarity with Dependency Injection/Inversion of Control, JSF, and JPA/Hibernate persistence is a plus.

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

Grails provides a tremendous jump-start to any web application. With easy scaffolding and zero-configuration ORM, you're up and running in no time. But what's needed to effectively move from a vanilla Grails project to a fully-customized application fit for public consumption?

In this session, through live demos we'll explore techniques for quickly securing our application, implementing effective (and DRY) UIs, developing Grails services, extending Grails with plugins, and even integrating with Java when the need arises.

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 Pramod Sadalage

Evolve an existing database schema a small bit at a time to improve the quality of its design without changing its semantics.

For years the norm for object developers was to work in an evolutionary (iterative and incremental) manner but for database developers to work in a more serial manner. The predominance of evolutionary development methodologies such as Extreme Programming (XP), Feature Driven Development (FDD) make it clear that the two groups need to work in the same manner to be productive as a team.

Pramod will present material from the 2007 Jolt Productivity Award winning book "Refactoring Databases : Evolutionary Database Design" on how to go about doing evolutionary database development, how to apply all the agile practices to database development and will talk about the following techniques:

Database refactoring: Evolve an existing database schema a small bit at a time to improve the quality of its design without changing its semantics.

Continous Integtration: Why not test you database creation and migration scripts as part of Continous Integration and apply the same rigor to the database artifacts that you apply to the application code. You should fail the build when the developer/dba makes a mistake doing a database change

Evolutionary data modeling: Model the data aspects of a system iteratively and incrementally, just like all other aspects of a system, to ensure that the database schema evolves in step with the application code.

Database regression testing: Ensure that the database schema actually works.

Configuration management of database assets: Your data models, database tests, test data, and so on are important project artifacts which should be managed just like any other artifact.

Database Schema Deployment: Ensure that the scripts used to build development environments are the exact same as the used in QA, UAT and production. Ensure deployment to production is not a surprise and not a project in itself.

By Pramod Sadalage

is your database being tested and integrated like your application code? do you have a database integration strategy? do you have a process to upgrade your database as you make subsequent releases? Make the database part of your Continuous Integration cycle and benefit from it.

It?s considered very difficult to integrate the database, the way application developers integrate their code frequently. Pramod will describe a proven way to integrate the database with the application code and show a way to make it part of the same application code repository. The practice of "Continuous Integration" changed the way software is written, then why not extend the practice to include database in the Continuous Integration cycle, so that you can see integrated results of your application and database work.

Every time a new release of the application is deployed, invariably there are problems with the upgrade/migration of the database. Pramod will show how to create a process where you can upgrade your production databases using upgrade scripts created during development time and how these upgrade scripts can be tested so that you will save time and sleep when deploying applications into production.

As a series of recipes, Pramod will show how DBAs can be effective members of evolutionary teams, delivering value and expertise to the team, how your team can still be distributed across continents and be successful while evolving the database. The recipes are

Continuously Integrating Extracting your database in scripts Using Version control for your database Automating database or schema creation Creating objects in your database Removing database objects Removing your database Using the build.properties files Re-Creating your application database for any build Making it easy for new developers to join the team Integrating on every check-in Strategy for naming Upgrade scripts BuildNumber Timestamp UniqueIdentifier Release Automating Database change script creation Implementing database version checking Sending database upgrades to customers

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

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

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

By Brian Sam-Bodden

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

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

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