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
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 David Geary
In April 2005, annual growth rates for jobs in JavaServer Faces, Struts, and Ruby on Rails were all at about 0%. Today, Struts' growth rate still hovers around 0%, but JSF and Rails have taken off. At the end of 2007, both JSF and Rails were growing at a rate of between 400-500% annually (according to indeed.com).

JSF has passed the adoption tipping point, and is now the Java-based framework of choice, as is evidenced by its ecosystem. From vendors such as MyEclipse and RedHat to open source projects such as Seam, Facelets, and Ajax4JSF, JSF is where the action is.

Come see why JSF is so popular. In this code- and demo-intensive session, I'll show you the fundamentals of JSF.

This session is taught by a member of the JSF Expert Group for JSF 1.0 and 2.0., and co-author of the best-selling book on JSF: Core JavaServer Faces. David will take you through a whirlwind introduction to JSF including what JSF is, how it was developed, and how you can best take advantage of the technology. Here is a list of topics:

Components, managed beans, value expressions, and static navigation
i18n, CSS, and actions
The Faces Context and Faces messages
The JSF Event Model
Using JavaScript with JSF

This introduction to JSF also contains 5 live-code demos, where David will develop a simple, but robust application during the course of the session.

Prerequisite: Some knowledge of Java-based web applications, such as Struts, is a plus, but is not required. If you have a significant experience with JSF, you probably already know most of what's covered in this session.

By David Geary
Facelets is a combination of Tiles and Tapestry, and it's the hottest JSF-related open source project on the planet. It's popularity is well deserved, and in fact, much of what is in Facelets today will make its way into the JSF 2.0 spec due out in 2008. So not only can you come to this session and see some really cool demos that you can put to use in the real world, but you'll also be learning JSF 2.0 before it's even been defined! How's that for a ROI?

This session is 90 minutes of nothing-but-Facelets, so we're going to cover a good bit of ground. You'll see all of the basics, such as templating, error handling and debugging, and some of the more advanced aspects, such as creating your own components and tag libraries.

Prerequisite: Some knowledge of JSF is essential. If you're familiar with a templating framework, such as Velocity or Tiles, that's a plus, but not required.

By David Geary
This talk explores the RichFaces Ajax framework, which is really two frameworks: Ajax4jsf and RichFaces components. In this session you will see how to implement low-level Ajax functionality using Ajax4JSF, and how to use high-level Ajax components from RichFaces.


The JSF spec has changed little since JSF debuted in 2004. However, the open source community is a frentic cauldron of activity that has produced lots of cool innovations, many of them related to Ajax. In this talk, we'll look at two of the most popular open source Ajax frameworks for JSF: Ajax4jsf and RichFaces.

Ajax4jsf gives you a very capable set of low-level Ajax tags (JSP or Facelets), along with their corresponding APIs, that let you easily incorporate Ajax features, most of the time by just using a custom tag or two. Ajax4jsf is an ideal solution if you want to add Ajax functionality to an existing JSF application.

RichFaces components is a library of components built on top of Ajax4jsf. You get basics such as toolbars list shuttles, and a MS Virtual Earth component.

In early 2008, the JSF Expert Group has begun to focus it's attention on incorporating concepts from best-of-breed JSF Ajax frameworks, such as Ajax4jsf and ICEfaces. What you learn in this session will give you both a preview, and a leg up, on JSF 2.0.

Prerequisite: Some knowledge of JSF is required, in addition to familiarity with Ajax.

By David Geary
Have you ever stopped to think that you need to learn two frameworks to develop a non-trivial, database-backed, web application? Struts and iBatis; JSF and Hibernate; Tapestry and EJB3.0.

Two frameworks. And then you have to learn to use them together. Why do we have to learn two frameworks just to retrieve "Hello World" from a database and show it in a view. Isn't that crazy?

Now you can use one framework, and use one component model. One. Isn't that nice?

By David Geary
The Google Web Toolkit (GWT) is truly a revolutionary framework that lets you develop Ajaxified web applications without knowing anything about Ajax or JavaScript. But the GWT goes way beyond basic Ajax by letting you implement desktop-like applications that run in the ubiquitous browser.

In this, the first of a two-part session on the GWT, you will learn about the framework and its fundamental capabilities, such as: rapid development with project and application generators; the GWT widget hierarchy; remote procedure calls; the GWT's history mechanism, including its integration with the Back button and bookmarks; and integrating JavaScript frameworks, such as Script.aculo.us, with your GWT applications.

By David Geary
In the second part of this talk, you will learn how to extend the GWT by implementing custom widgets, including a scrolling viewport and a drag and drop framework. After discussing custom widgets, you will see how to integrate database access into your GWT applications, and how to deploy your GWT applications to external servers.

You will also learn how to integrate GWT widgets into legacy applications built with web application frameworks such as Struts, JavaServer Faces, or Tapestry. The GWT is one of the most powerful Ajax frameworks on the planet, and one of the few that let you easily implement desktop-like applications that run in a browser, and because of that, it has gained incredible mindshare in a short period of time. Come to these two sessions on the GWT and see what all the buzz is all about.

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

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

By Jared Richardson
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 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
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
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 Mark Fisher
The first part of this two-part session will focus on the essentials of Enterprise Integration with Spring. The discussion will cover the enterprise integration support libraries in the Spring Framework core within the context of well-established design principles such as loose coupling and separation of concerns.


The presentation is driven by examples that progressively extend an application with various integration capabilities such as remoting, messaging, scheduling, and management. Attendees will leave with a clear understanding of Spring's core integration support and an appreciation for the benefits of using Spring's dependency injection, templates, and proxies. After this session, you will be fully prepared to explore Spring Integration, a new addition to the Spring portfolio, in Part 2.

By Mark Fisher
The second part of this two-part session will introduce Spring Integration, a new addition to the Spring portfolio. We will begin with a high-level overview of Enterprise Integration Patterns as catalogued in the highly influential book of the same name. We will then embark on a demo-driven exploration of Spring Integration to see how it enables the development of applications based on those patterns.


Patterns we will discuss include Message Channel, Channel Adapter, Message Endpoint, Content-Based Router, Message Translator, and more. We will also take an in-depth look at the APIs so that you will understand how to provide extensions while maintaining the separation of concerns that is essential for producing maintainable, testable code.

Prerequisite: Enterprise Integration with Spring, Part 1

By Mark Fisher
In this session, we will take a deep-dive into annotation-based dependency injection with Spring 2.5. You will learn how to combine annotation and XML formats, how to customize component scanning, and how to leverage Java 6 annotations within a Spring application. Since there is no "one size fits all" solution to application configuration, we will wrap up the discussion with general guidelines to consider when employing this approach.

Although XML is the most widely used format for Spring configuration, other options do exist including properties files, Spring's Java Configuration, and even Groovy builders. Spring 2.5 adds to this mix with support for Java's @Resource annotation and Spring's @Autowired annotation. Spring 2.5 also supports classpath scanning for Spring components. This session will provide a comprehensive overview of these new Spring 2.5 features for annotation-based configuration.

By Neal Ford
This session demonstrates how stringent TDD improves the structure of your code.

I discuss TDD as a technique for vetting consumer calls, using mock objects to understand complex interactions between collaborators, and some discussions of improved code metrics yielded by TDD. This session shows that TDD is much more than testing: it fundamentally makes your code better at multiple levels.

By Neal Ford
This session demonstrates that "Agility" and "SOA" complement each other quite well. Just because SOA is buzz-word compliant doesn't mean that you should throw good practices out the window. This session demonstrates how you can apply the principles of agility to building highly complex distributed enterprises.

Managers and ivory tower architects seem to think that all the rules that apply to "normal" software don't apply to SOA. Ironically, they matter even more. Agility and SOA are closely aligned because SOA is about building complex distributed systems and Agility is about effectively building complex software. This session unveils the pillars of successful SOA and how to achieve them in a testable, iterative fashion. It discussing testing strategies, how to make your architecture more robust and maintainable, and how to design an evolutionary architecture.

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
It turns out that ancient philosophers knew a lot about software -- did you know that Plato defined object-oriented programming? This keynote applies old lessons to new problems and old problems to new lessons. It describes why SOA is so hard, and why people in your company make bone-headed decisions. What other keynote includes Rube Goldberg, Aristotle, Dave Thomas, and Chindia?

Plato, Aristotle, Occam, Rube Goldberg, Dave Thomas, and Demeter...with pictures!

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
Ruby is the revenge of the Smalltalkers. Not since Smalltalk has a language had such powerful meta-programming facilities. While this may seem like a minor feature, it turns out that surgical meta-programming allows solutions to problems that are clearer, more concise, more maintainable, and take orders of magnitudes fewer lines of code.

This session shows one of the reasons that JRuby is the most
powerful mainstream language today: meta-programming. It shows tons of
meta-programming techniques in Ruby, including open classes, the shadow
meta-class, defining methods, method_ & const_missing, dynamically
adding and removing mixins, and more. And each of these comes with an
example that actually makes sense!

Session Topics

• Modules
• Structs
• Freezing
• Messages and Dynamic Invocation
• The Shadow Meta-class
• Code as Objects
• Delegation
• Open Classes
• Aspects
• Missing!
• Const
• Method
• Reflection
• Mixology

By Neal Ford
Developers from the 1980s would be shocked at how inefficiently developers use their computers because of the advent of graphical operating systems. This talk describes how to reclaim productivity afforded by intelligent use of command lines and other ways of accelerating your interaction with the computer and bending computers to do your bidding. Stop working so hard for your computer!

In The Productive Programmer, I identify 4 principles of productivity: this talk goes into great detail on 2 of those principles. It 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 ways to speed up development by taking command of your computer. This includes keyboard shortcuts (including ways to learn them and make better use of them) in both IntelliJ and Eclipse. Automation refers to making the computer do more work for you. This talk includes tons of examples, all culled from real-world projects. Note: This is a companion talk to my other talk, Productive Programmer: Canonicality and Focus, but each talk is completely independent of the other -- they are not "Part 1" and "Part 2".

By Neal Ford
Getting work done in modern office environments is a daunting task. This session tackles 2 of the things that drag down developer productivity: lack of focus and creeping repetition.



In The Productive Programmer, I identify 4 principles of productivity: this talk goes into great detail on 2 of those principles. This session defines the principles of Canonicality and Focus, 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. I show examples of creating DRY documentation, O/R mapping, database schemas, and development environments. Focus describes how you can utilize your environment (both physical and computer) to greatly enhance your productivity. This talk includes tons of examples, all culled from real-world projects. Note: This is a companion talk to my other talk, Productive Programmer: Acceleration and Automation, but each talk is completely independent of the other -- they are not "Part 1" and "Part 2".

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 decision. Developers will get information in the trade offs when using strategy or the other, and how these strategies can be used together with the same persistence unit.

Other tips such as fetch groups, flushing, and caching will be covered as time allows. The presentation will use Weblogic application server, OpenJPA/Kodo, and Spring as the basis for the examples. The presenter has experience with using both Hibernate and OpenJPA so can speak to the portability of these two JPA implementations and its affect on coding.

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 Groovy to spice 'em up. Don't toss out your existing unit tests. (You are unit testing, aren't you? AREN'T YOU?) If not, Groovy is the perfect excuse to get started with a new language in way that improves the quality of your Java application without actually putting the new code into production. That is, until you get hooked on doing things the Groovy way...

If the Red Pill of Dynamic Languages scares the pants off of you (or your manager), don't worry about it. The Blue Pill still offers plenty of benefits. There is no other language on the JVM that offers you the level of deep Java compatibility such that you could rename your "dot J-A-V-A" files to "dot G-R-O-O-V-Y" and not skip a beat. Of course, they both end up with a "dot C-L-A-S-S" extension at the end of the day, so there's good chance that no one would ever be the wiser anyway. Groovy: funny name, serious software, and Java through-and-through.

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, however, the Red Pill looks interesting, please join me. Remember, all I'm offering is the truth. Nothing more.

By Scott Davis
Struts is the defacto web framework for Java web developers. It has been with us since 2001. Struts enjoys unprecedented success -- most surveys place its market share between 60% and 70%. It introduced a whole generation of web developers to the phrase 'MVC' (Model / View / Controller).

Grails 1.0 was released in 2008. It marries the modern features of Rails with the need for legacy support for Struts. Grails is inspired by Rails, but it is not a simple port of the project to Java. It takes the ideas of Rails, but expresses them in familiar Java libraries like Spring and Hibernate. It also leverages a new dynamic language for the JVM called Groovy.





In 2004, Ruby on Rails added some new phrases to the industry like 'scaffolding' and 'Convention over Configuration'. While these concepts helped ease the pain of traditional Struts development, they added a bit of a wrinkle: Rails wasn't implemented in Java, so the developer was forced to learn a completely new programming language. This had a ripple effect new IDEs, new web servers, new supporting libraries to learn, and on down the line. While greenfield development was a breeze in Rails, supporting legacy Java applications was relegated to high-level integration technologies like Web Services and shared databases. The views and business logic had to be rewritten from the ground up in the new language.

Many of Rails early successes were with brand new websites built from scratch. This talk, however, is targeted at developers who have successful Struts applications already in production. We'll start by using Groovy to strategically ease the pain points of an existing Struts application. Your organization might decide to stop there. However, we'll begin migrating one portion of the Struts application at a time into Grails until we eventually have something that is ready for the 21st century. Who knew that Struts development could be exciting 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
Groovy is a new dynamic language that dramatically speeds up Java development. Grails is a complete web framework in a box, including a web server and a database. Google Maps allows you to add maps to your webpage in a few lines of code. Put all three together and you are built for speed.

In this talk, Scott discussed how to incorporate Google Maps with your database-driven web application. Mashing up local data is one thing: mapping data from other websites like Google Calendar is just as easy. Groovy's XML parsing capabilities make dealing with web services a breeze. Creating mashup means understanding both web services and Ajax-based mapping services. This talk provided sound fundamentals in both. The rich toolsets out there allow you to spatially-enable data that you never thought of mapping.