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




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

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

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

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

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

Prerequisite: Beginning Drools

By Brian Sam-Bodden
Learn 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
- Distributed Caching
- Profiling your queries
- Using bags
- Using filters for virtualization
- Custom SQL for performance
- Query caching
- ... and more

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


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

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

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

By Brian Sam-Bodden
This session explores some of the programming techniques that a powerful dynamic language enables, in particular meta-programming or the art of writing code that writes code. Meta-programming techniques are being used extensively in many successful frameworks based on dynamic languages such as Rails, Grails and countless others. Learn how you can use meta-programming in Groovy to improve and streamline your Java applications.

This session explores some of the programming techniques that a powerful dynamic language enables, in particular meta-programming or the art of writing code that writes code. Meta-programming techniques are being used extensively in many successful frameworks based on dynamic languages such as Rails, Grails and countless others. Learn how you can use meta-programming in Groovy to improve and streamline your Java applications.

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 David Bock
Agile software development isn't just about the development team or managers... the customer has an active role too. The customer should be prioritizing the stories in each release, potentially working onsite in constant contact with the development team, and even participating in daily status meetings.

Done well, the customer's presence has a positive influence on the development iteration. Done poorly, the customer detracts from the team's focus. So how do you be the customer of an agile team? How do you teach someone to be that customer?


In this session we will look at an overview of agile methodologies and the role of the customer, customer proxy, and other versions of the "product owner", and their responsibilities in ensuring the success of an agile software development project.

By David Bock
Estimating is regarded as little little more than 'educating guessing', but so much can hang on the quality of those estimates. With good estimates we can set clear expectations for project delivery, but with bad estimates we can run over schedule and over budget, or worse. We often estimate when we know the least about the work that needs to get done - so how can we make the best of what is potentially a bad situation?

In this session we will look at how successful agile teams estimate the scope of work at the beginning of a project, estimate the amount of work that fits into any one iteration, track the work through the iteration, and the 'burn down' through the end of the project. We will look at 'low ceremony' estimation techniques like planning poker, trim down 'high ceremony' techniques like Wideband Delphi, and look at "FET+", an estimation technique originally developed as a foil for a CMMi effort.

With a little effort, a little planning, a little tracking, open communication, and some good metrics, estimation does not have to be a 'crystal ball' activity.

By David Bock
Maven is a build tool that does a lot, demos well, and leaves the build maintainers managing what seems like unbridled complexity. It doesn't have to be that way - Maven is driven by some strong 'build process methodology', and that complexity can become manageable by wrapping your head around it. Furthermore, you can migrate to Maven 'piecemeal', by mapping your existing ant build to the Maven Lifecycle and calling your existing Ant tasks - you can decide to sip the Maven kool-aid.

Ideally, a build tool should be so simple and approachable that it fades into the project background and allows anyone to maintain it. Unfortunately, Maven's power comes at the expense of this ideal - Maven's philosophy is more like "the build process is so important that the people maintaining it should be steeped in the ways of Maven". This talk will give you the exposure you need without elevating The Maven Way to a religion.


In this talk we will cover:

Internals of the Maven POM
Integrating Maven with Eclipse
The Maven Build Lifecycle, and hooking your own goals into it
Calling Ant tasks from Maven
Extending your build with existing Maven Plugins
Maven subprojects and the SuperPOM
Writing your own Maven Plugins

By Howard Lewis Ship
Part one (of two) covers the TestNG unit testing framework, and shows how it integrates with Selenium (for integration testing).

In part one of this two part session, we'll discuss the basics of unit testing and show how to use TestNG. We'll discuss how to use the tool, organize tests, and collect results, as well as integrate with IDEs, Ant and Maven. Lastly, we'll see advanced uses of TestNG combined with Selenium to automate integration testing within a test suite.

By Howard Lewis Ship
In part two (of two) we go in depth on EasyMock, the weird and wonderful tool for creating mock objects on the fly. We'll do a good bit of live coding as we examine how to use, tame and extend this powerful tool.

Unit testing with only gets you so far; even when you've refactored your code and hidden all your implementations behinds interfaces you are still stuck with the problem of testing the individual pieces. If you've hit this point and despaired, know that there are tools to help ... including the weird and wonderful EasyMock. We'll discuss unit testing in general, and how EasyMock is used to to generate mock objects, allowing you test each class in isolation. We'll be doing some live coding to show you step-by-step how to build up a unit test, interpret EasyMock's baffling error messages, and set yourself up for easy reuse of testing code.

By Howard Lewis Ship
Tapestry 5 is a complete rewrite of Tapestry from the ground up. It takes everything good about Tapestry and cranks the volume up to eleven, while removing the frustrating parts of using Tapestry. This session takes the wraps off this new and innovative technology, showing off important new features such as live class reloading (the ability to change your Java classes and continue using the application without interruption or redeployment), the simplified coding model, and the total lack of XML. This session is of interest to those already using Tapestry 4, and those new to Tapestry and ready to jump on the bandwagon.

Tapestry 5 really does take everything great about Tapestry and crank it up, all with the goal of making your job as a web developer easier. Being able to change your classes at will within a running application is just the tip of the iceberg; Tapestry 5 is designed to break down the barriers to developer productivity by simplifying every aspect of creating a web application.

Tapestry 4's base classes and abstract methods are all gone, replaced with pure POJOs and a handful of annotations. All the XML configuration of Tapestry has been removed as well. Tapestry 5 practices convention over configuration with a vengeance, introducing smart defaults and intelligent logic to let Tapestry do the right thing.

By Howard Lewis Ship
Everyone likes the Gang of Four design patterns, but it's not always clear just how to make use of them in your day to day coding efforts. Hidden inside Tapestry 5 is an Inversion of Control (IoC) container that is structured around several common patterns (Chain of Command, Strategy, Decorator and Filter Chain will be covered). This isn't academic navel-gazing ... this is about leveraging the common patterns so that you can write code you can easily test, and about creating frameworks and toolkits that can be easily extended.

We'll see how Tapestry uses these patterns, and go from there into how you can apply the same techniques to your own projects, resulting in better, cleaner, more testable code.

This session also serves as an introduction to the Tapestry 5 IoC container.

By Jared Richardson
Software projects fail over and over for many of the same reasons. We'll look at some of the more avoidable problems and some solid ways to fix them, or avoid them in the first place.

We'll talk about discovering what went wrong (and what went right!) with your last project, solving code integration issues, resolving lingering quality problems, establishing automated test suites, reining in soaring project requirements and more.

By Jared Richardson
There are a number of great techniques you can use across technologies and projects. Come hear some of my favorites and contribute a few of your own. We'll discuss topics from DRY to creating a zone defense for your product.

In this session we'll discuss:
-grassroots process improvement
-DRY code: why and how
-establish a zone defense for your code
-tracer bullets
-test automation
-lunch and learn
-the home server
-leaving your comfort zone for fun and profit

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

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

By Jared Richardson
Has your career been a random product of your manager's whims or company's needs? Never rely on your company to keep your skills current and marketable. Take control of your own career with a proven strategy.

These are solid, repeatable steps to get your career in the trajectory you want. The first step is deciding where you want to go. We'll walk through creating a long-term plan, then break it down into manageable steps. Learn to lead within your own company, then stretch out to your local, regional and national community, building your reputation as you go. From coding to writing to speaking, each step will move you closer to where you want to be: in a position of having options and in control of your career.

By Jared Richardson
Technical debt has long been recognized in technical circles for years, but convincing your manager to budget time to repay "technical debt" has always been problematic. Let's couch the term technical debt concept in language more familiar to our managers: credit card debt.

Like credit card debt, technical debt accumulates slowly over time, and usually takes just as long to pay off. The interest slowly builds up until you're no longer able to pay off the principle: your entire development cycle is devoted to just "paying the interest". We'll examine common types of technical debt and strategies to effectively communicating the problems, and their solutions, to your managers.

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

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

By John Heintz
REST is a description of how the Web works, what use is that to developers just trying to build or integrate applications?

This presentation introduces REST, explains the key differences/constraints, and then highlights how these concepts can improve key parts of application and service development:
* scalability, integration, evolvability

Introduction to REST
Constraint-based Architecture
Hypermedia
Properties of REST
Constraints of REST
Conclusions

By John Heintz
In this session you will learn about the Glassbox open source troubleshooting and monitoring tool. Glassbox enable detection of common application problems such as database failures, slow operations, thread contention, and excessive distributed calls. Glassbox enables low overhead monitoring and troubleshooting without needing to "bake in" instrumentation up front.



Glassbox provides an intuitive Ajax Web interface, an automated installer and concise summaries of common problems out of the box. Glassbox focuses first on highlighting the underlying cause of a problem without requiring a person to sift through volumes of profiling information. Glassbox also supports customization and detailed analysis for deeper investigation. Under the covers, Glassbox uses JMX and Aspect-Oriented programming to discover applications, track performance, and automatically diagnose common problems in Java applications.

You will see how Glassbox can be extended easily (with XML, AspectJ and Spring AOP) to providing a useful foundation for customized application monitoring. Glassbox is open source and can be downloaded freely from http://www.glassbox.com/.

By John Heintz
Java's Annotations provide a way to add data to program elements. Annotations are used to configure containers, describe persistence configuration, set security roles, and are defined by nearly every recent JSR standard. This presentation explains the processing options available for consuming Annotations and demonstrates the techniques with live code demonstrations.



The presentation:
* introduces Annotations and how to create custom Annotations,
* surveys the techniques that can add implementation effects from Annotations (code generation, bytecode transformation, runtime reflection),
* demonstrates adding behavioral effect to an example with APT, Reflection, Javassist, and AspectJ,
* wraps up with best practices for using and defining Annotations.

No prior experience is necessary, and attendees will learn how to define and to provide behavior for custom Annotations in their own systems.

By John Heintz
This presentation introduces and demonstrates Liquibase: a new Java tool to support automating database refactoring and deployment.

Agile Database tools and techniques have been evolving to catch up with the existing support for source code. Many projects struggle to keep external databases (and DBAs) in sync with rapidly changing and tested source development.

Support for Agile Database development needs to include tools support for the following areas:
* Database Refactorings
* Schema Version Control
* IDE Support
* Scripted tools (Ant, Maven, command line)

Liquibase is an LGPL-licensed Java tool for tracking, managing, and applying database changes. Liquibase enables the database schema, reference data, and data change scripts to be managed as effectively as source code on Agile projects:
* the CI build doesn't break from forgotten SQL script runs
* developers don't have to coordinate check-ins/outs with each other
* embedded or external databases can be managed with the same scripts
* databases can be automatically upgrades, or SQL generated for review

This presentation introduces these topics and demonstrates Liquibase with an example application showing Spring Framework, Ant, and continuous build integrations.

By Joseph Nusairat
JBoss Seam is one of Java's ways of providing agile development to enterprise Java applications. Seam is designed to take away the headache of linking JSF, EJB3, AJAX, and jBPM by using interception directed by
user defined annotations. The end result is smooth and easily manageable code without the plumbing usually required for functionality. This session will take you through the process of how Seam works, creating a sample application, and what Seam can buy you for enterprise setup including the pros and cons.



Ever since the J2EE spec was released people have been writing code to cope with the awkwardness of a specification written by tool vendors for tool vendors. Generally this involved implementing patterns, writing wrappers, and writing custom frameworks to handle what should have been part of the specification. Resumes began to be cluttered with items like ?service locator pattern? and ?front controller pattern? experience. As needs grew so did the Java Community and they responded accordingly. Frameworks like Spring and Hibernate grew out of need and necessity to accommodate what was lacking. However, one area has been constantly lacking in enterprise applications is the glue to bring it all together.
Seam grew out of this need to seamlessly, no pun intended, tie different components and Java frameworks together. What started out as simple glue for EJB3 ? JSF has grown rapidly and with fanfare. Not only was it used to glue presentation to business tier but many other components as well like mail, rules engines, PDFs and now one can even write Seam beans in Groovy.
In this presentation we will go over what Seam is and what Seam can offer a development team. Seam can solve problems that normally required custom frameworks. While custom frameworks are always fun to develop, they take up resource time and can bring in another area of instability to the application.
Whether your application is a simple web store or a complex enterprise application Seam can be used to cut development time down, and let your developers focus on the items that count: the business logic, the presentation, and your domain structure.

By Joseph Nusairat
Vital to any development is the ability to test that application. Most frameworks have their very own testing suites, EJB3 is no exception and their are a variety of testing apparatuses. We will examine testing with JBoss Embedded, EJB3Unit and mocking with Easy Mock and JMocks.

Testing with EJB3 produces new issues that most developers have not seen locally. For one thing, their are generally no DAO's when dealing with Java Persistence API. Because of this it makes whats normally called integration or container testing more valuable even at the unit level, since no other piece of the application will be testing them directly.
In this session we discuss two of the major ways to perform integration testing. The first is through a light container called EJB3Unit. This is an easy to set up testing framework that uses HSQL as the underlying database. However, EJB3Unit is more of a cross between unit and integration testing, for full on Integration testing we will use JBoss Embedded to get a richer feel.
In addition, when using the integration frameworks is not as necessary, or when you need to add some mock testing to your EJB3Unit tests we will discuss two mock frameworks. The first are EasyMocks, the second is a newer framework that allows a bit more versatility called JMockIt.
By the end of this you should be ready to go and test your EJBs thoroughly.

Prerequisite: Knowledge of EJB3.

By Joseph Nusairat
This presentation is designed to give users an introduction to what Grails has to offer. The presentation will show how fast one can get up and running with Grails.

For the last decade we have been trying to get web application development performed faster and faster. Struts was the first Java web application that had wide spread adoption to start to get web application development faster. Of course years later we realized it was still quite slow. Along the way came items like Spring, Hibernate, Ruby on Rails, and finally Groovy. All of these pieces together, and quite a bit of hard work from many people helped to bring together into the framework we know as Grails.

This presentation will show how one can create a web application that meets all your needs much faster and more agile than before with Grails. We will cover the basics of starting from scratch, creating your models, views, and domains to have a fully built application in the end.

By Keith Donald
Spring has a number of interesting modules for web application development, including Spring Web MVC, Spring Web Flow, Spring JavaScript, and Spring Faces. This session will provide an overview of these modules and show how they relate to one another. By the end of this session, you'll understand how Spring simplifies the development and deployment of rich web applications. You'll also gain a glimpse into the roadmap for Spring Web 3.0.

Spring Web MVC is a popular web framework, and the base platform for powering Spring-based web applications.
Version 2.5 introduces significant new features that simplify the core MVC programming model, including support for annotated @Controllers.

Also building on the Spring MVC platform are a number of interesting extensions. Spring Web Flow 2 adds significant new features for implementing flows within a Spring MVC-based app. Spring Faces, a new module, provides groundbreaking support for JavaServerFaces in a familiar Spring MVC environment. And last but not last least, Spring Javascript, a new module, integrates leading UI toolkits such as Dojo into a Spring MVC environment.

Come to this session to get an update on the state of Spring Web, see how to put these technologies into practice, and learn what's coming in Spring Web 3.0.

By Keith Donald
Web Flow is a Spring Web MVC extension that allows you to define Controllers using a higher-order domain-specific-language. This language is designed to model user interactions that require several requests into the server to complete, or may be invoked from different contexts. This session dives deep into the features of the Web Flow definition language, and illustrates how to use it to create sophisticated controller modules.

In this session you will learn:
- How to implement reusable controller modules as self-contained bundles that can be refreshed without container restart
- How to solve the back button problem and duplicate submit problem
- How to handle Ajax events and render partial responses
- How to simply data access concerns and prevent lazy loading exceptions by using flow-managed persistence
- How to secure flows, including their startup
- How to test your controller logic
- General best-practices for designing and implementing flows
- Techniques for achieving flow reuse, including use of flow definition inheritance
- Guidelines for deploying flows alongside Spring Web MVC multi-action @Controllers
- How to implement common user interaction patterns such as master detail, wizard, and tabbed UI.

By Keith Donald
Spring JavaScript is a JavaScript abstraction framework that allows you to progressively enhance a web page with behavior. The framework consists of a public JavaScript API along with an implementation that builds on the Dojo Toolkit. Spring.js aims to simplify the use of Dojo for common enterprise scenarios while retaining its full-power for advanced use cases. Come to this session to learn to use Spring.js and Dojo to create compelling user interfaces.

This session will walk through using Spring.js to add a number of rich web capabilities to your applications, including:
- Decorating standard HTML links and forms with Ajax events
- Linking in partial updates to a page
- Adding effects such as progress indicators, blinds, and popups
- Performing client-side validation

In addition, you'll see how Spring.js can help with:
- Gracefully degrading when JavaScript is not available
- Meeting requirements for accessibility
- Applying progressive enhancement techniques

By Keith Donald
Spring Faces is an innovative project that allows native JSF components to work inside a familiar Spring MVC and Web Flow environment. This combines the best of action-oriented and component-oriented approaches, and can greatly enhance the development experience and reduce the learning curve of building and running a JSF web application. In this session, attendees will take a deep dive into how Spring MVC and Web Flow enable this model and add power and simplicity in the areas of navigation control, state management, and application modularity.


In this session you will learn:
- How to implement reusable application modules as self-contained bundles that can be refreshed without container restart
- How to solve the back button problem and duplicate submit problem
- How to handle Ajax events and render partial responses
- How to simply data access concerns and prevent lazy loading exceptions by using flow-managed persistence
- How to secure application modules
- How to test your application logic
- General best-practices for designing and implementing navigation rules
- Techniques for achievingreuse
- Guidelines for deploying stateful navigations alongside REST-ful Spring Web MVC multi-action @Controllers
- How to implement common user interaction patterns such as master detail, wizard, and tabbed UI.

By Kito Mann
JavaServer Faces, the standard Java web development framework, has gained quite a few fans and detractors over the past few years. Regardless of the camp, most agree that the framework can improve. JSF 2.0, currently under development through the Java Community Process, aims to be a dramatic leap forward for the framework.

This session covers enhancements, changes, and new features currently under discussion by the JSF 2.0 expert group. These include improved Ajax support, better UI component interoperability, simpler component development, a Facelets-style template language, automatic re-deployment of application artifacts, and several other goodies.

Prerequisite: familiarity with JSF

By Kito Mann
For developers who are currently using Spring and JavaServer Faces together, this session explains how to handle common application development concerns such as conversational scope, transaction management, and application partitioning.

For developers who are currently using Spring and JavaServer Faces together, this session explains how to handle common application development concerns such as conversational scope, transaction management, and application partitioning.

Specific tools such as Apache MyFaces Orchestra and Spring WebFlow will be discussed. At the end of this session, developers will understand how to build a full-stack JavaServer Faces/Spring/Hibernate or JPA application with features similar to those of JBoss Seam.

By Kito Mann
The benefits of using JavaServer Faces UI components to rapidly construct complex, interactive user interfaces have become quite clear over the past couple of years. However, the standard process for developing these UI components is currently quite tedious. Fortunately, there are better solutions available.

This presentation examines techniques for easing the process of developing components with techniques such as annotations, convention over configuration, and templating. We'll examine solutions based on JSP tag files, Facelets, and Apache Shale. In addition, we will discuss how JSF 2 will simplify the process.

Prerequisite: Basic understanding of JSF.

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 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 Mark Johnson
Development teams are increasingly scattered all over the world, often a development manager now days will never meet the entire team face to face.

This session will explore useful metrics for managing distributed development teams and keeping the project on-time and on-budget.

By Mark Johnson
How do you know when you are "DONE" and the assignment is complete? Well of course you are done when your requirements are complete. But it always happens that your interpretation differs from the customer/management's interpretation.

This session will explore the use of FitNesse to create "Business" readable test cases before development even begins so you can agree with your customer as to what "DONE" means and prove that you have actually completed the requirements to specifications.

By Mark Johnson
This session will explore GroovyWS as a tool to quickly produce and or consume a web service. Web Service testing becomes much easier without the need to purchase expense testing tools using the GroovyWS framework.

In this session we will take some code examples to demonstrate the creation of a web service and its consumption using GroovyWS. Also, using GroovyWS and other utilities the session will demonstrate how to dynamically test web services.

By Mark Johnson
With all of these web services becoming available there is an increasing need for tools to pull together multiple web services into one composite service. BPEL is an up and coming approach to orchestrating a workflow consisting of Web Service calls.

This session will go beyond the vendor specific graphical workflow design tools to introduce the BPEL language constructs. Using real BPEL code examples applied to a couple of problem domains we will introduce concepts which can get you started developing SOA Workflow applications.

By Mark Johnson
You have just received the much desired promotion to Technical Team Lead The team is waiting your direction. You What should you do now?

This session uses discussion to explore common pitfalls encountered by new Technical leads as well as possible solutions.

By Pratik Patel
Doing basic Object-to-Relational Mapping is fun and easy with JPA. Annotate your persistent classes, define a couple of configuration parameters, and you're off and running. This session starts with a basic object model and adds persistence using annotations. Learn how to do mappings for your object model for simple and complex relationships. Also learn how to map Java5 constructs like Enumerations.

Unit testing with JPA can be tricky. Where do you use mock objects? How can I structure my unit tests to exercise my DAO's effectively? How do I unit test JPAQL? Do I need to enhance or can I use a LoadTimeWeaver in my unit tests? This presentation will show, using live code examples, how to effectively unit test JPA components so developers can have confidence in the code they build using JPA.




Now that we have some tests, we'll get into querying for data using JPA. JPA uses JPAQL, or the Java Persistence API Query Language. JPAQL is the object-oriented, rather than standard SQL, way of querying your persisted objects/data. Using many live code examples, developers will gain an understanding of how to write JPAQL. We'll also explore the very useful bulk update & delete feature of JPAQL.

By Pratik Patel
As with many technologies, the basics are easy. The hard part comes when the developer needs to do sophisticated integration, development, and testing as part of an enterprise application. A large enterprise application requires the developer to think of issues that affect the development, scalability and robustness of the application. This presentation will cover the advanced topics described below.

A large enterprise application often will have several sub-projects that each contain their own JPA persistence unit. This opens up a number of questions around how to organize the persistence units and how the code between sub-projects should interoperate. Developers will gain insight into these issues and will see a couple of solutions using live code examples.




Many enterprise applications require integration with an application server's JTA mechanism. JTA integration allows for JPA components to work with container managed transactions and distributed transactions. A typical usage scenario for JPA & JTA is this: read from a database using JPA, perform some business logic, put a message on a queue, write to the database (again using JPA). A JTA transaction allows you to ensure that the entire set of operations is committed or a rollback is performed. In this presentation, the developer will understand the limitations and configuration of using JTA and JPA together ? primarily through real code examples.

Once unit tests are written, developers often gloss over doing fine-grained integration testing just for their persistence layer. Integration testing with JPA means simply one thing: running your JPA components against your target database, for example, Oracle. Overlooking this aspect leads to problems being discovered later in the test cycle (UAT for example) and makes it more difficult to find and fix bugs. This presentation will use live code examples to explain a strategy for getting integration testing for free by reusing unit tests.

Using optimistic locking versus pessimistic locking seems clear cut to most developers. However, a full understanding of the issues with using pessimistic, or datastore, locking is required before making this