Session Schedule

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

There are wild-eyed radicals out there telling you that Java is dead, statically-typed languages are passe, and your skills are hopelessly out-of-date. Those extremists are the same ones who don't bat an eye at throwing out years of experience to learn a new language from scratch, pushing aside a familiar IDE for a new one, and deploying to a whole new set of production servers with little regard to legacy integration.

While this "burn the boats" approach to software development might sound exciting to some folks, it's giving your manager the cold shakes right now. What if I told you that there was a way that you could integrate seamlessly with your legacy Java code, continue to use your trusty IDE and stable production servers, and yet take advantage of many of the exciting new dynamic language features that those fanatics keep prattling on about? You'd probably say, "Groovy!" I would, too...

This talk focuses on integrating Groovy with your legacy Java codebase in a way that wouldn't raise an eyebrow in the most conservative of organizations. We'll look at the dramatic reduction in line of code you can achieve by simply flipping your POJOs (Plain Old Java Objects) to POGOs (Plain Old Groovy Objects). We'll talk about calling Java classes from Groovy, and calling Groovy classes from Java. We'll look at Groovyc, the integrated compiler that manages Groovy/Java dependencies without a hiccup. Not once will I tell you to throw out the old in favor of the new. In each case, I'll show you how to integrate the new with the old. Don't throw out your Ant build scripts; mix in a bit of Gr

By Scott Davis

This talk focuses on the ways that Groovy can turn a traditional Java developer's world-view upside down. We'll start by talking about how you can thumb your nose at The Man by leaving out many of the main syntactic hallmarks of Java: semicolons, parentheses, return statements, type declarations (aka Duck-typing), and the ever-present try/catch block. Then we'll look at features like operator overloading and method pointers that Groovy welcomes back into the language with open arms.

The bulk of this session focuses on metaprogramming with Groovy. We'll add new methods to classes at runtime -- even if they were originally implemented in Java, and even if they were declared final. (Thanks, ExpandoMetaClass!) We'll call methods that don't exist and avoid the dreaded MethodNotFound Exception. (Thanks, invokeMethod!) We'll narrowly scope our metaprogramming shenanigans using Use blocks and Categories, and then cast our changes to the wind such that every instance of a class gets our added juice. If you are happy taking the Blue Pill, this talk is not for you. You can continue using Groovy as a slimmed-down dialect of Java -- an 'After' picture to Java's 'Before'. If, howeve

By Scott Davis

Struts enjoys an unprecedented marketshare in the Java web development space -- 60%-70% according to most surveys. As newer, modern web frameworks come to the scene, very little attention is paid to the real costs of migrating an existing Struts application. This talk shows you ways to mix Groovy into a legacy Struts application, dramatically reducing both the lines of code and the complexity. We'll also introduce you to Grails (a Groovy-based web framework) whose URL-mapping capabilities allow it to replace your Struts application without breaking legacy URLs.

Grails is a modern Web development framework that mixes familiar Java technologies like Spring and Hibernate with contemporary practices like convention over configuration. Written in Groovy, Grails give you seamless integration with your legacy Java code while adding the flexibility and dynamism of a scripting language. After you learn Grails, you'll never look at Web development the same way again.

By Scott Davis

How optimized is your website? YSlow, a FireFox/FireBug plugin, doesn't pull any punches. It gives any website an A, B, C, D, or F rating based on 14 individual analysis points. You'll be amazed (or depressed) at what YSlow thinks of your site. In this talk, we'll walk through these points step by step, learning what Yahoo! (the creator of this utility) does to keep its web properties running as quickly as possible.

These points are nicely summarized in "High Performance Web Sites", by Steve Souders (a companion book to the plugin). The analysis points that YSlow looks at are programming language, server, and web framework agnostic. The lessons learned here are really a deep look into HTTP, taking advantage of the native capabilities of the protocol -- making the Internet work for you.

By Scott Davis

JavaScript Object Notation is becoming a familiar delivery platform for Web 2.0 content. JSON gives you all of the flexibility of a RESTful web service without the hassle of trying to deal with deeply nested, complex XML in a language that is conspicuously lacking in native XML support. In this talk, we look at popular websites (like Yahoo!) that offer JSON output. We look at client-side JavaScript code that effortlessly consumes JSON in the browser. We even look at ways to easily generate JSON from Java Servlets (using JSON.org libraries) and the native support for JSON that Grails offers out of the box.

This talk also gives us the opportunity to brush up on our JavaScript, as well as look at clever ways that JSON can work around Cross-Site Scripting issues.

By Scott Davis

Based on the book GIS for Web Developers, this talk demonstrates how you can build your own Google Maps in-house using nothing but open source software. The Portland, Oregon Transit Authority recently migrated from a proprietary web mapping solution to the suite of 100% free and open source software discussed in this book. We look at Java-based clients, Java-based servers, and everything in between. We also discuss integrating free, public domain data from sources like the US Census Bureau and the USGS. If you're looking for real-world examples of AJAX in use, you'll find it here. If you're looking for real-world examples of web services in use, you'll find it here.

We start by exploring free datasets out there in the wild. They are stored in a myriad of file formats (some proprietary, some open) and projections. Free tools like GDAL and uDig make it easy to convert them and visualize them. Once the data is normalized, we store it in a PostgreSQL/PostGIS database. Not only does the database centralize the mapping data, it opens up quite a few interesting querying capabilities. Serving up the data is the final piece of the puzzle. We look at web services based on the OGC (Open Geospatial Consortium) standards. We use Tomcat and the GeoServer WAR to expose our data via OGC interfaces. We look at a couple of Ajax-based mapping frameworks (MapBuilder and O

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

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 -

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's approach to integrating JavaServerFaces technology is novel and innovative; an approach that lets you maximize your investment in Spring while still adhere to standard JSF idioms. In this session, Keith will go "behind the scenes" and explore the framework architecture underpinning Spring's JSF integration. Attendees will gain valuable framework design and architectural insight.

A deep-dive design session into how Spring and JSF integrate, and how the integration has evolved over the years.

By Stuart Halloway

The rise of Ajax and Rich Web Applications, plus the success of dynamic languages, has caused people to revisit the JavaScript language. Now that we take JavaScript seriously as a language, it is time to get serious about the quality of JavaScript code, through refactoring. In this talk, we will test and refactor a real-world jQuery plugin.

As we refactor a real-world jQuery plugin, you will learn how to test JavaScript code with Screw.Unit, Smoke, and blue-ridge write covering tests for existing code perform common refactorings such as extract method and "use the right tools" rethink refactoring in light of functional programming style think about when and how refactoring shades into breaking changes and redesign

By Stuart Halloway

Git is not the next step in evolution of centralized source control, following in the footsteps of cvs, svn, etc. These tools provide centralized history of deltas, where git provides distributed history of trees of content. In this talk, you will see the advantages of the git approach:

Incredible speed. Local, disconnected operation. Source control workflow customized to your team. Centralized, distributed, or layered, you can build it with git. Cheap and easy branching, tagging, and merging. Editing and refactoring your commits.

You have probably heard about git by now, perhaps something along these lines: "Git is a version control system, and it is more powerful that Subversion in every way. You don't even have to be online to commit!" This is true, but it undersells git. Git is not the next step in evolution of centralized source control, following in the footsteps of cvs, svn, etc. These tools provide centralized history of deltas, where git provides distributed history of trees of content. In this talk, you will see the advantages of the git approach: Incredible speed. Local, disconnected operation. Source control workflow customized to your team. Centralized, distributed, or layered, you can build it with gi

By Stuart Halloway

Over the last few years, we have taken dozens of projects to 100% coverage, and there are still plenty of things that can go wrong. We will look at examples the various problems, and show how to prevent them from infecting your project.

With an expressive language such as Groovy or Ruby and with modern test practices, 100% C0 test coverage is readily achievable. But 100% coverage is meaningless without other supporting habits and practices. Over the last few years, we have taken dozens of projects to 100% coverage, and there are still plenty of things that can go wrong. We will look at examples of each of these problems, and show how to prevent them from infecting your project: * Fragile mocking * Pair bravado * The ugly mirror * Parallel abstraction * Overspecification * Underspecification * Invisible code * Misplaced exemplar

By Stuart Halloway

In this talk, we will explore and compare four of the most interesting JVM languages: Clojure, Groovy, JRuby, and Scala. Each of these languages aims to greatly simplify writing code for the JVM, and all of them succeed in this mission. However, these languages have very different design goals. We will explore these differences, and help you decide when and where these languages might fit into your development toolkit. For more information see http://blog.thinkrelevance.com/2008/9/24/java-next-overview.

As we reach the middle of our second decade of Java experience, the community has learned a lot about software development. Many of our best ideas on how to use a Java Virtual Machine (JVM) are now being baked into more advanced languages for the JVM. These languages tend to provide two significant advantages: They reduce the amount of ceremony in your code, allowing you to focus on the essence of the problem you are solving They enable some degree of functional programming style. Think of it as a dash of verb-oriented programming to spice up your noun-oriented programming. In this talk, we will explore and compare three of the most interesting new JVM languages: Clojure, Groovy, JRuby, an

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

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 brea

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

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 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 Richard Monson-Haefel

An effective software architect understands that every application is different and requires unique choices regarding programming language, middleware, integration, data access, user interface design, etc. Richard Monson-Haefel has distilled knowledge from his own experience and from personal interviews with the World's best software architects to define 10 principles every software architect should know in order to be effective.

Developers aspiring to become software architects and experienced software architects a like will walk out of this session better prepared and more confident in their decisions as software architects.

By Richard Monson-Haefel

With literally hundreds of RIA products (e.g., Adobe Flash, Nexaweb, Backbase) and open source Ajax projects (e.g. Dojo, GWT, Prototype) to choose from. Picking the right RIA technology for the job requires months of research. Richard Monson-Haefel has been researching and writing about RIA alternatives for two years and has already done the research so you don't have to.

This session will explain the differences between RIA alternatives and provide a framework for selecting the best product or open source project for your application. The choices for RIA technologies seem mind boggling, but after this session you'll know the market and be able to choose the right solution easily.

By Richard Monson-Haefel

What does GPL, LGPL, MIT, Apache licenses, copy left, and dual licensing mean? Richard Monson-Haefel explains both the legal and technical implications of the major open source licenses in plain English. He explains when and how you can use open source in the enterprise and in the development of software products and how to protect your organization from abusing open source licensing.

You may walk into this session confused about open source licensing, but you'll walk out crystal clear on how open source licenses work and the difference among them.

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

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 J

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 scra

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

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 favorite ways to move "beyond" and contribute a few of your own. We'll discuss topics ranging from glue languages to ditching your IDE to building your brain.

In this session we'll discuss: - Move beyond tools - Glue languages - Inbox Zero - Learning to learn - Not being a cog anymore - Macro Object Orientation - Clean code - Looking smarter than you are - Open source tool stacks - Tighter feedback loops - Scripted deployments - Scripting databases - Virutalization And more...

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

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 - Caching - Profiling your queries - 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.