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
Hibernate is an open source Object-Relational Mapping Framework that mostly automates the tedious and time-consuming task of persisting Java objects to a relational database.
Hibernate is quickly becoming the preferred way for enterprise developers to overcome the object-relational impedance mismatch and a good alternative to the coarse-grained Entity EJBs, low-level raw JDBC, and by-committee specifications like JDO. Learn what your choices in the ORM arena, what to look for in an ORM tool, and how to get started with Hibernate for your next J2SE or J2EE project.

Hibernate is an open source Object-Relational Mapping Framework that mostly automates the tedious and time-consuming task of persisting Java objects to a relational database. Hibernate is quickly becoming the preferred way for enterprise developers to overcome the object-relational impedance mismatch and a good alternative to the coarse-grained Entity EJBs, low-level raw JDBC, and by-committee specifications like JDO. Learn what your choices in the ORM arena, what to look for in an ORM tool, and how to get started with Hibernate for your next J2SE or J2EE project.

In this session you will learn:
- Understanding the O/R Impedance Mismatch
- Techniques of O/R Mapping
- Persistence Frameworks in Java
- Architecting Persistence into your application
- Hibernate Architecture and Overview
- Installing and configuring Hibernate in J2SE
- Hibernate in a J2SE application
- Mapping Persistence Classes
- Domain Models
- Object Identity
- Dealing with Inheritance and Schema Associations
- Understanding the lifecycle of persistent objects
- Understanding Hibernate usage in a J2EE application
- Overview of advanced topics

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
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
Ajax4jsf makes it very easy to add Ajax to your JSF applications. Come to this presentation to see how.

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 one of the most popular open source Ajax frameworks for JSF, Ajax4jsf.

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.

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.

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 David Hussman
With the growth of agile comes the need to add a new line to the Agile Manifesto: Success over Dogma. The number of people who can say agile is growing faster than the number of people benefiting from agile practices. There are now many successful agile projects, yet there are also a growing number of projects claiming to be agile but not seeing any of the benefits agile methods provide. This session will discuss successful adoptions of agile, dumb things you can do to muck it up, and more.

Just saying you are an agile project does not mean you will benefit. If agile methods are going to work for you, you will need to make them work in your culture. This session will review the healthy and no so healthy use of agile methods. Drawing from a wide variety of examples across many companies and domains, the session will provide guides for adopting or tuning agile methods that will work within your company culture and not simply in some text book. We will also cover near misses and common landmines that many agile projects encounter.

By David Hussman
Management and agility are not mutually exclusive. Many managers are already working in an agile manner as a means to improve, produce, or simply survive. Other managers hear about projects using agile methods and struggle to find a place in the project community.

This session provides a new way to think about managing projects. Some managers will find that their existing practices and skills are supported and enhanced by the forums and metrics provided within an agile project while others will be challenged by some of the principles and practices.

From product definition to project chartering to planning, estimating, and tracking, this session will discuss practices of agile managers working on agile projects of all sizes. The session will contains a collection of interactions meant to teach, challenge, and immerse you in the managing and leading an agile project.

By David Hussman
Successfully coaching agile communities involves using a wide variety of skills. Coaches help guide coding and design, collaboration and communication, the writing and telling of user stories and much more. The coach needs to continuously show and teach the varied interactions that connect and support the entire project community.

This session will explore and teach coaching skills. The session will reference a wide variety of agile coaching as well as drawing from cross disciplinary techniques like those used by music producers to help foster creativity while helping to ensure products are delivered and challenges confronted.

We will discuss ways to help a community find their groove in the first few iterations and we will end by talking about techniques for keeping the groove alive past the first release and into the future of the project.

Some of the many areas that will be covered are:
- Organizing and leading a chartering session
- Creating a creative work space
- Helping to write stories and build an initial backlog
- Getting people talking and collaborating
- Raising awareness with meaningful metrics and information radiators
- Connecting with the difficult or uninterested players
- Growing community coaches

By David Hussman
Why should the value of test driven development (TDD) stay stuck in the realm of coding? The ideas behind TDD are now being successfully applied to the automation of business value. While this has been going on for some time within the agile community, it is not starting to spread to main stream development.

There are more tools are coming available everyday which allow developers, testers, and customers (or product owners) to work together to automate acceptance tests. This process helps clarify the needs of the end user before development begins and removes more of the wasteful work based on incorrect assumptions from vague requirements.


This session will talk about how to get people working together to automate acceptance testing. We will cover the creation of testable work units, like user stories, the collaboration around creating the initial acceptance tests, and several ways for various people in your project community to come together to automate acceptance tests and delivery more and better software.

By David Hussman
Being agile does not mean living life one iteration at a time. Agile projects without a long view can run into the common design problems of the past. Planning iteration by iteration is often foolish and feeds the myth that agile projects do not think beyond a few weeks. Successful agile projects plan within iterations and across iterations. The later planning is called release planning and it is the forum where agility first engages architecture and other cross cutting concerns.

Architects who think that agile projects evolve code one test at a time are only partially correct. Agile projects review and evolve architecture with unit tests, acceptance tests, architectural spikes, and continuous review of the system's ability to adapt and respond.

There is a home for architects and architecture on agile projects, and other traditional roles, but the there are some new variations. This session will talk about the relationship of agile methods and architecture and design and how they can work together to make stronger products and systems. The session will draw on information and anecdotes will come from projects of all sizes within companies of all sizes, including some large and complex systems.

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
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 Jeff Brown
Groovy is an agile dynamic language for the Java platform. The language and its libraries bring many things to the table to ease the process of building applications for the Java platform. This session provides a detailed run through Groovy with lots of code samples to drive home the power of the language.

Dynamic languages provide a lot of power and flexibility compared to statically typed languages. Groovy brings that power and flexibility to the Java platform in a way that is totally compatible with all of your existing Java code, tools and infrastructure. This session covers all of the fundamentals of Groovy and gives developers a whole lot of practical information they need to get started with the language.

By Jeff Brown
Dynamic languages bring a lot of interesting elements to the table for teams interested in doing Test Driven Development (TDD). Groovy lends itself very well to TDD and this session demonstrates many features of the language and its libraries that help teams build more testable systems and build better tests.

The value of Test Driven Development (TDD) has become widely accepted. The practice has extended beyond just XP teams. Good TDD practices yield high quality software and help teams maintain confidence in their software as complexity grows. The dynamic nature of Groovy makes TDD easy and fun. Groovy may be used to unit test not only Groovy code but other code as well. Testing Java code with Groovy is a snap. Learn to use the power of Groovy to test your systems.

By Jeff Brown
Metaprogramming is a key component in building truly dynamic and flexible applications with Groovy. Groovy's metaprogramming capabilities bring great new possibilities to the table that would be very difficult or just plain impossible to write with Java alone. This session will demystify a lot of the magic that seems to be going on inside of a Groovy application.

When Java developers are first introduced to Groovy one of the first things they notice is how much easier things are in Groovy compared to Java. Boilerplate code typically generated by your IDE all melts away to nothing in a Groovy bean. Creating XML is a snap, not a tangled mess. File I/O is a breeze. Those developer productivity gains are an important part of the story. However, in addition to making easy the things you are used to doing the hard way Groovy brings whole new capabilities to the party that Java developers don't even think about because you can't do those things with Java. Many of those capabilities are made possible because of the powerful metaprogramming capabilities of the language. Learning the metaprogramming capabilities of the language takes developers the rest of the way to fully taking advantage of the power of Groovy. The metaprogramming capabilities offered by the language provide everything that an application development team needs to build systems that are far more capable than their all Java counterparts.

Prerequisite: A Thorough Introduction To Groovy

By Jeff Brown
Grails is a full stack MVC framework for building web applications for the Java platform. Grails makes web application development both fun and easy. This session covers all of the fundamentals of building web applications with Grails.

Businesses need rich web applications and developers want to be able to build those applications without the pain that usually comes along with doing so. Grails addresses these needs very well. Grails demolishes many of the pain points that Java developers have almost (not quite) become numb to after years of suffering. This session covers all of the fundamentals:

- Introduction To Grails
- Domain Objects
- Controllers
- GSPs
- Custom TagLibs
- GORM

By Jeff Brown
Grails makes web application development both fun and easy. This session dives beyond the basics to cover advanced details of Grails that bring the really exciting features to your applications.

Getting started building web applications for the Java platform is easy. Following that through to rich interactive applications that solve the business needs is more tricky. Grails goes the whole way to address pain points not only for simple applications but of real enterprise applications with real demands. This session steps through many of the advanced features of Grails that help get your applications through that last 20% that teams often struggle with.

Prerequisite: Grails - Agile Web 2.0 The Easy Way

By Ken Sipe
Scale... what is scale... how do you applications which are scalable. How do you know if the application scales?

This session will look at server topologies and state management and how it effects scale. We'll detail a number of metrics to know and observe. In addition tools of the trade will be demonstrated such as jmeter.

By Ken Sipe
Well the standards created EntityBeans.... yea. and the community created Hibernate. Fortunately the standards body learned some lessons and created JPA. JPA requires a vendor implementation and none make a better choice then Hibernate. Combined with Spring this trio is a powerhouse when it comes to developer productivity on applications requiring persistence.

This session will look at in detail the persistence capabilities of the latest Spring 2.5 and how to provide data access capabilities, including nicely added features for unit tests. We'll focus the persistence discussion on JPA and examine a number of ORM mapping scenarios and how JPA maps to them. We'll focus on the spring integration including transactional capabilities.

By Ken Sipe
Spring 2.5 is brand spanking new, with a number of fantastic features. With growth of large and complex Spring applications which struggle with xml manageability and with the added pressure of Guice and SEAM there is a push for less XML, with solution leaning towards annotations. Spring 2.5 adds to the toolset provided in Spring 2.0 to provide a development environment where XML is greatly reduced... or eliminated if you so choose.

The session walks through the new Spring 2.5 enhancements, then dives deep into annotation oriented injection. The demonstrations include standard applications as well as a look at the new Spring MVC.

By Ken Sipe
The success of an Agile / SCRUM project is a successful start. The first interaction is often referred to as iteration 0. Other iterations have a set of stories with clear acceptance certain which establishes the velocity of the team and its effort. What then is accomplished in iteration 0? How do we get an Agile process started.

This session will outline all the "pre" activity tasks which led into an agile development process. As well as the establishment of a tasklist of iteration 0, include the establishment of development environment, configuration management details. This will include several case histories examples of Iteration 0.

By Ken Sipe
SOA... Is it hype? What's real... and what's not? What is the right abstraction level?

The purpose of this session is to challenge the practicality of SOA and discuss the questions that we need to answer about service oriented techniques, practices and tooling. What is the right abstraction level for a service? Where does PBEL fit? When is an ESB appropriate or not?

Everyone seems to be blindly accepting the enterprise needs an ESB or SOA. This session will focus on the facts of software development and the challenges which exist today with SOA. Where are SOA techniques being abused? If you are interested in SOA this session is for you. If you are tired of the SOA hype this session is for you. Much of the discussion will stem from experienced based principles of software architecture, with a look at where SOA provides a solution and where it does not.

By Michael Nygard
If your software fails in production, nobody will care how great the development project was, or how well the system passed QA. Production operations, the domain of your systems' least-appreciated stakeholders, is where the rubber meets the road. Come learn how to build your systems to thrive in Operations.

If you don't want to wear a pager for the rest of your life, this session is for you.

We will explore the most critical foundations for success in Operations: transparency, control, deployments, and configuration.

Along the way, we'll see some of the organizational dysfunction that prevents smooth, successful operations. You'll learn what you can do today to avoid these dysfunctions, even if you've inherited a legacy of distrust between Development and Operations.

By Michael Nygard
Servers, storage, networking, backups... they're all vanishing into the "clouds". Cloud Computing is the emerging architecture for massive, scalable infrastructure that your company doesn't have to own or operate.

From the "zero servers" web startup to the corporate IT department battling server-sprawl, cloud computing has many manifestations. This session will differentiate among the various types of cloud computing and describe applicable use cases.


The term "Cloud Computing" can be applied to everything from Software-as-a-Service (formerly known as Application Service Provider) to virtual infrastructure, grid computing, and even remote backup services. Some of these make sense, but some are just bandwagon-jumping and buzzword bingo.

In this session, Michael will discuss the ingredients of real cloud computing and how you can apply it to gain competitive advantage. He will show several cloud computing structures and discuss applications that fit each of these models. Finally, he will also talk about some of the pitfalls and problems that cloud computing customers can encounter.

By Michael Nygard
Cloud computing is taking the world by storm. Amazon's Web Services, EC2, and S3 provide completely virtual infrastructure, letting startup and existing companies create sites and web applications faster than ever before.

In this session, Michael will use cloud computing to create and deploy a fully-functional web site. You will learn how to create and run your own virtual infrastructure in the clouds.

It used to take weeks and months to stand up a new site. You had to buy hardware, rent (or build) space, rack, stack, and cable it, and then you'd finally get to start installing operating systems, databases, and so on.

These days, none of that is necessary. You can run a real business on the net without ever owning anything. Best of all, you can be up and running in a single day.

A day? Trivial you say? OK, we'll make it an hour and a half, with time for questions.

By Nathaniel Schutta
Thanks to Ajax, JavaScript is cool again and developers are taking a second look at this much maligned language. This session will give you an overview of this misunderstood language as well as opening your eyes to some of the excellent tools available to ease the pain of developing in this dynamic language.

Thanks to Ajax, JavaScript is cool again and developers are taking a second look at this much maligned language. This session will give you an overview of this misunderstood language as well as opening your eyes to some of the excellent tools available to ease the pain of developing in this dynamic language.

By Nathaniel Schutta
While your project might have nearly 100% code coverage on the server tier, many projects ignore testing the web layer. With more and more code being pushed to the browser, a lack of tests for the client code begs for trouble.



This talk will explore several testing options including Selenium, JsUnit, Crosscheck, JSCoverage, Watir, JSLint, JSSpec and others.

By Nathaniel Schutta
So you've convinced the boss that your new web application just has to have Ajax...but now what? With dozens of libraries making even the most blinkish of interactions trivial, how do you decided where to sprinkle the magic Ajax dust? This talk will give a plain old boring "web 1.0" an Ajax facelift with a focus on improving the user experience providing you with a game plan for introducing Ajax to your world.

So you've convinced the boss that your new web application just has to have Ajax...but now what? With dozens of libraries making even the most blinkish of interactions trivial, how do you decided where to sprinkle the magic Ajax dust? This talk will give a plain old boring "web 1.0" an Ajax facelift with a focus on improving the user experience providing you with a game plan for introducing Ajax to your world.

By Nathaniel Schutta
We'll pick up where Part 1 left off working in even more advanced approaches such as offline support with Google Gears.

We'll pick up where Part 1 left off working in even more advanced approaches such as offline support with Google Gears.

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
Grails is a Java- and Groovy-based web framework that is built for speed. First-time developers are amazed at how quickly you can get a page-centric MVC web site up and running thanks to the scaffolding and convention over configuration that Grails provides. Advanced web developers are often pleasantly surprised at how easy it is to break out of that coarse-grained navigation model using the native Ajax support baked into the framework.

We'll start with the solid Web 1.0 foundation that Grails provides and mix in JavaScript libraries like Prototype and Scriptaculous. (Both are included with the framework.) Grails tags like remoteLink and formRemote make it easy to asynchronously replace strategic parts of the web page while leaving the whole unchanged.

There is first-class support for JSON (JavaScript Object Notation) in Grails. You'll see how easy it is to return JSON (and XML) instead of the usual HTML using the grails.converters package.

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

By Stevie Borne
In agile teams, are testers needed if the developers write automated tests? Is there a need for BA's if the developers are supposed to talk directly to the customer/business? How do PM's fit into an agile team?

This presentation will address these questions and more, giving hope to the non-developers because they do have a place on agile teams.

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 approach refactoring JavaScript in three phases:

Test first, then refactor. Bring JavaScript code under test, so that you can refactor with confidence.
Refactoring 101. Explore some important refactorings: composed method, extract method, introduce named parameter, and extract object
Common problems. Work through three problems endemic to legacy JavaScript code: making JavaScript unobtrusive, refactoring to prototype-based inheritance, and refactoring to functional style.

The rise of Ajax and Rich Web Applications, plus the success of