This is the year of the dynamic scripting language. Ruby (and Rails) has won the hearts and minds of many independent software developers. JavaScript is experiencing a renaissance thanks to the wild success of AJAX and websites like Google Maps. And Groovy (JSR-241) brings the same level of excitement and "scripting goodness" to the Java platform.

In this presentation, we take a very pragmatic "prove it in code" approach to learning Groovy. Since the syntax is (almost) identical to Java, we can dive right in from the very beginning, learning the "syntactic sugar" as we solve real world problems.

You'll learn how easy it is to install Groovy and get started working with it. You'll tackle file I/O, reading and creating text files. You'll create and parse XML and HTML. You'll interact with databases. You'll create Groovlets (servlets sprinkled with Groovy-dust). And finally, you'll get a brief introduction to Grails (hint: the 'G' is silent).

I'm attracted to Groovy because of its spirit of inclusiveness. Because it extends my platform of choice, not replaces it -- include a single JAR in your classpath and you are Groovy-enabled. Because it offers full bidirectional integration with Java. Because it offers a nearly flat learning curve for experienced Java developers. Come see how you can use Groovy to augment your existing Java codebase.

We'll look at calling Groovy from Java. We'll look at calling Java from Groovy. We'll look at compiling Groovy code, JARring it up, and deploying it alongside Java.

Groovy offers the same level of integration with Ant. We'll look at Ant tasks that allow you to include Groovy in your build process. Or maybe you'd prefer to use the Groovy AntBuilder and completely manage your build in code. The choice is yours. The important thing is Groovy works along side your familiar toolkit instead of forcing you to replace it.

Scott Davis is the Editor in Chief of aboutGroovy.com. The website, in addition to being, umm, about Groovy, is implemented in Grails. This talk shows you how to get started with Grails, but also talks about the experience of using it in a live, production web site.

Grails is a fully integrated, modern Java web development stack. In a single zip file, it includes a web server (Jetty), a database (HSQLDB), a build system (GANT, a Groovy/Ant hybrid), a logging framework (Log4J), and a unit testing framework (JUnit). It also includes mainstream libraries like Spring for dependency injection, Hibernate for Object/Relational mapping, Quartz for scheduling, and SiteMesh for page layout. For Ajax, Grails allows you to choose between three major included technology stacks: Prototype/script.aculo.us, the Yahoo UI library, and Dojo. Coupling the power of these mainstream libraries with the ease-of-use that Groovy offers, you have an unprecedented collection of technologies that will have you up and running in record time.

Grails maximizes the strengths of these familiar Java libraries while minimizing the XML jockeying it usually takes to get them all to play nicely with one another. It brings "Convention over Configuration" to Java. It uses Groovy as the language to glue the pieces together, which means that experienced JEE developers can learn Groovy in the context of libraries that they are already familiar with.

It is no exaggeration to say that you will have your first Grails application up and running in minutes. But Grails is more than about a quick start. In this talk, we'll look at ways to move beyond the default configurations. We'll deploy a Grails app to an external Tomcat instance instead of the included Jetty server. We'll move from the default HSQLDB database to MySQL. We'll include external JARs to bring new functionality to the mix.

"Which framework should I use?" is the question most often heard on the No Fluff, Just Stuff tour. It's well worth asking. Unfortunately, there is no simple answer. After years on the tour, most speakers have crafted a response that would make any Washington politician proud -- long on style, but essentially, "Well, it depends..."

In this humorous keynote, Scott Davis turns to unconventional sources for enlightenment. Could best-sellers like Blink, Freakonomics, The Tipping Point, The Paradox of Choice, and The Wisdom of Crowds finally solve the puzzle? In this "Da Vinci Code"-like romp through the conventional wisdom of the day, will the Holy Grail of web frameworks be revealed? Probably not, but possible side effects may include nausea, dry mouth, and insight into the eternal question of our industry.

In this talk, we'll survey the web services exposed by leading websites (Google, Yahoo, Amazon, eBay) and discuss how they can be easily mocked up for testing purposes and to aid offline development. You'll see working examples of RESTful, SOAP, and JSON web services, as well as strategies for unit and functional testing your asynchronous, service-oriented architecture.

As more software engineers add unit testing to their everyday development regime, the concept of mock objects is becoming increasingly popular. Mock objects proxy more complicated objects, fulfilling their doppelganger's interface and behavior for testing purposes. Coding to interfaces instead of implementations is a best practice that applies equally well to POJOs and Web Services.

Web Services, too, are being added to our toolkit with increasing frequency. Building a true service-oriented architecture brings with it new challenges: how do you code against an external service? If that service is metered, how do you develop iteratively without using up your production budget in tests? These questions and more are answered in this talk.

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

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

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

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

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

Many demonstrations of new technology focus on the shiny turnkey features -- "Look at what this thing magically does for you out of the box!" While Grails has many gee-whiz scaffolding features, it is a framework first. A framework should "make easy things easy and hard things possible." (Apologies to the Perl community for co-opting their battle cry.) This talk focuses on the hard things that are possible with Grails, but require just a bit of glue code to implement.

Grails does a great job making 1:M relationships turnkey. Relating two tables is as simple as adding a line of code to each class. The web scaffolding generates combo-boxes automagically. M:M relationships, on the other hand, require a bit of elbow grease. We'll explore 1:M and M:M in Grails and how to best present them via the web interface.

We'll also look at things like how to best handle file uploads, how to manage user authentication, and even how to incorporate a Captcha into your forms. None of these are impossible, but each requires just a few additional strategic lines of code to handle.