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

Spring Security (formerly known as 'Acegi') enables self-contained, consistent, and extensible solutions for securing your applications. Version 2.0 provides major enhancements including a domain-specific XML namespace, convention-based defaulting, and annotation support. This provides a significantly simpler experience for developers while still supporting the same degree of flexibility.

Spring Security's interceptor-based approach is non-invasive even when extended to accommodate domain-specific requirements. The two main security processes (authentication and authorization) are decoupled in order to provide flexibility across a wide variety of providers and strategies. This presentation will include an overview of Spring Security's pluggable authentication process and how it accommodates a wide range of possibilities including Database, LDAP, Single Sign On, and even an in-memory option for development and testing. We will then proceed to cover authorization where you will see its consistent approach for securing web requests and method invocations. Throughout the session, we will walk through a sample application that demonstrates Spring Security's core features.

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

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: acceleration, focus, automation, and canonicality. This session 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. Focus describes how you can utilize your environment (both physical and computer) to greatly enhance your productivity. 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. Automation refers to making the computer do more work for you. This talk includes tons of examples, all culled from real-world projects

By Neal Ford

Most developers think that "TDD" stands for Test-driven Development. But it really should stand for "Test-driven Design". Rigorously using TDD makes your code much better in multiple ways.

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

What does code + methodology have to do with one another? Everything! Agile projects focus on delivering working code, and tools exist to allow you to verify some quality metrics for your code. This session is a survey of tools and metrics that allow you to determine the quality of your code and strategies to "wire it" into your agile project.

Agile projects focus on delivering code. The responsibility for the quality of that code lies with developers. Yet most developers have a poor sense of how to gauge the quality of code, both during development and forensically. This talk lives on the boundary between what is important in agile projects and ways to verify code quality. It is both a survey of tools and metrics and strategies for proactively applying these techniques to ongoing projects. I talk about the Hawthorne effect, analysis tools (both byte and source code), useful metrics, tools for generating metrics, and how to analyze raw data into actionable tasks.

Session Topics:

• The Hawthorne Effect
• How Agility and Metrics Feed Each Other
• Analysis Tools
• FindBugs
• PMD/CPD
• Testing Metrics
• Cyclomatic Complexity
• Chidamber and Kemerer Object-oriented Metrics
• JDepend
• Code Change Risk Analyzer and Predictor for Java
• Panopticode
• Tools

By Ted Neward

Java's threading capabilities took a serious turn for the better with the release of Java5, thanks to the incorporation of the java.util.concurrent packages, a set of pre-built components for thread pooling and execution, synchronization, and more.

In this presentation, we'll explore the Thread API, the Java threading model beneath it, and the enhancements made in Java5 to make it easier for Java code to walk and chew gum at the same time.

By Ted Neward

Java's threading capabilities have been a part of the Java platform since its inception, yet for many Java developers, using Threads still remain a dark and mysterious art, and synchronization beyond the use of the "synchronized" keyword is almost unknown.

In this talk, we'll explore the Java "monitor" concept, and how a monitor isn't quite the same thing as a lock from other concurrency systems. We'll see how monitors can be used to perform signalling across threads, and then how the new java.util.concurrent API (introduced in Java 5) can be used to simplify the same sorts of tasks that used to require deep knowledge of the synchronized keyword. Finally, we'll answer that age-old question, "Why did the multithreaded chicken cross the road?"

Prerequisite: The Busy Java Developer's Guide to Concurrency (Part 1: Threads)

By Ted Neward

If you've ever gotten a ClassCastException and just knew the runtime was wrong about it, or found yourself copying .jar files all over your production server just to get your code to run, then you probably find the Java ClassLoader mechanism to be deep, dark, mysterious, and incomprehensible. Take a deep breath, and relax--ClassLoaders aren't as bad as they seem at first, once you understand a few basic rules regarding their operation, and have a bit more tools in your belt to diagnose ClassLoader problems. And once you've got that, and hear about ClassLoaders' ability to run multiple versions of the same code at the same time, and to provide isolation barriers inside your application, or even compile code on the fly from source form, you might just find that you like ClassLoaders after all... maybe.

For a beginning to intermediate Java audience.

By Ted Neward

Permissions, policy, SecurityExceptions, oh my! The Java platform is a rich and powerful platform, complete with a rich and powerful security mechanism, but sometimes understanding it and how it works can be daunting and intimidating, and leave developers with the basic impression that it's mysterious and dark and incomprehensible. Nothing could be further from the truth, and in this presentation, we'll take a pragmatic, code-first look at the Java security platform, including Permissions, the SecurityManager and its successor, AccessController, the Policy class and policy file syntax, JAAS, and more.

For an intermediate-level audience.

By Ted Neward

Want to get the soup-to-nuts story on Java annotations? In this presentation, we'll first talk about what annotations provide to the Java language. After setting ourselves a conceptual basis to operate from, we'll look at the language definition for Java annotations, from how to use them to how to define them. Finally, we'll take a look at the other side of annotations, consuming them at source-level (using "apt", the annotation processing tool), class-level (using a bytecode toolkit such as BCEL), and at runtime (using enhancements to the Reflection API made in Java5).

For an intermediate Java audience.

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.

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.

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

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

In this session, Michael will discuss the ingredients of real cloud computing and how you can apply it to your applications. He will show several architectures 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.

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.

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.

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

Performance tuning any application is a black art that can consume much time. Fortunately, Java has many tools that can aid in this effort. There also are a number of basic tips that can help to analyze and fix performance problems. The Java memory model is usually something that you don't need to tune, but for high performance applications it is necessary to tweak. While there are a number of advanced things that can be done to performance tune an application, we'll discover that the simple, basic things are all that are usually needed to make your apps fly.

This session looks at how to setup and run an application with profiling tools and monitoring tools. We'll setup an application to run and put it under heavy load. While running, we'll interactively monitor it and look for problems and how to go about finding and fixing them. We'll also cover the basic issues you should look for when performance tuning. We'll look at memory management and how to tune it appropriately. We'll also look at some of the Java 6 tools available to monitor performance and look at the JVM internals. We'll focus on the simple things that can be done right away and then look at some more advanced tweaks to identify and fix performance issues. Along the way, you'll learn some of the tips and tricks to performance tune.

By Mark Richards

Awareness about Service Oriented Architecture (SOA) has grown significantly in the past several years. Unfortunately, along with that growth has come a significant amount of confusion about what SOA really is. SOA has become such a ubiquitous buzzword that it now has many faces and means different things to different people. CIO's, managers, vendors, business users, architects, and developers all see SOA differently which creates a sea of confusion about what is and isn't SOA. In this highly interactive and thought provoking session we will look beyond the hype and marketure of SOA and explore SOA from an architecture and development point of view - in other words, SOA as an architecture pattern. During this session we will look at SOA use cases, services, integration, implementation, guiding architecture principles of SOA, and attempt to answer the following question: What is and isn't SOA?

Agenda - SOA? Someone help me, please! - What is and isn?t SOA? - SOA Architecture Pattern Elements and Principles - What All This About an ESB? - SOA Challenges - Post Discussion - Summary

By Mark Richards

The chances are good that at some point in your career you will need to use messaging to pass information between applications, subsystems, or external systems, particularly with service-oriented architecture on the rise. The Java Messaging Service (JMS) allows Java applications to implement messaging using a standard API, thereby removing the dependency on any particular messaging provider. In Part 1 of this session we will take a look at some of the basics of messaging, including sending and receiving messages, message types, and request/reply messaging. I will begin the session by going over the basics of messaging and the JMS API. Then, through interactive coding using OpenJMS I will demonstrate how to connect to JMS providers, send messages, receive messages, and use message properties. Please note that this is a two part session.

Agenda:

JMS Basics - Messaging Models Overview - JMS Message Structure - Primary JMS Interfaces - JMS Providers - Internal vs. External Destinations Practical JMS - Obtaining a JMS Connection - Sending a Message to a Queue - Receiving a Message from a Queue - Using Message Properties - Implementing Request/Reply Messaging - Message Correlation

By Mark Richards

In Part 1 of the JMS session I covered messaging models, messaging basics, the JMS API, and point-to-point messaging. In this interactive code-intensive session I will cover some additional JMS topics such as browsing queues, load balancing, publishing and subscribing to messages within the pub/sub model, durable and non-durable subscribers, message selectors, and message filtering. I will also discuss and demonstrate message prioritization, persistent and non-persistent messages, and finally message expiration (expiry). Note that this is Part 2 of a two-part JMS session.

Agenda: - Browsing Messages - Load Balancing - Publish and Subscribe Model - Durable Subscribers - Message Selectors and Filtering - Persistent and Non-Persistent Messages - Message Priority and Expiration (Expiry)

Prerequisite: Enterprise Messaging With JMS (Part 1) or some knowledge of JMS

By Mark Richards

Java Persistence has come along way since the days of straight JDBC coding and custom framework development. We have at our disposal several outstanding open source frameworks such as Hibernate, Toplink, iBatis, and OpenJPA (just to name a few), and we now have a promising and emerging standards-based solution called Java Persistence API (JPA). However, all to often we find in the Java persistence space that it is a world of one-size-does-not-fit-all. We continually struggle with traditional ORM solutions like Hibernate when it comes to reporting queries, complex queries, complex relationships, and stored procedures, and we also struggle with managing the enormous amount of SQL required for solutions such as iBATIS or JDBC-based frameworks. In this coding-intensive session we will take a detailed look at identifying and overcoming the challenges we face when using frameworks such as Hibernate, iBATIS, and JPA, and how to combine the various persistence frameworks to create an effective Java persistence solution that approaches (but of course does not reach) the silver bullet.

Agenda: - Introduction - Framework Differences - Brief Overview of iBatis - Brief Overview of JPA - Aspect Analysis - Inserts and Updates - Reporting Queries - Stored Procedures - Complex SQL - Debugging and Testing Techniques - The Fast Lane Reader Pattern - Combining ORM and SQL Mapping Frameworks - Summary and Q&A

By Mark Richards

Most web-based applications rely solely on the database to manage transactions, thereby freeing the developer from having to worry about transaction management. While this works in some circumstances, there are times when the use of transactions is vital to the integrity and operations of an application and its corresponding data. In this session I will demonstrate through real-world coding examples why transactions are such a critical part of the application development process. I will review the basics of both programmatic and declarative transactions, then introduce three transaction design patterns and explain when they should be applied, how to use them, and what problems they solve. By the end of this session you will see that by using transaction design patterns you can build an effective transaction management strategy for your application with very little effort.

Agenda:

• Why Transactions Are Necessary
• Programmatic Transaction Management (EJB, Spring)
• Declarative Transaction Management (EJB, Spring)
• Transaction Design Patterns Overview
• Client Owner Transaction Design Pattern
• Domain Service Owner Transaction Design Pattern
• Server Delegate Owner Transaction Design Pattern
• Summary

By Nathaniel Schutta

When starting a new project, most developers make sure that testing is a priority. However, only the lucky few live in the idyllic world of greenfield development; the vast majority of us must contend with code written when "test" was a four letter word and testing was the sole responsibility of that "other" organization. We'll examine some techniques for introducing testing - not just to your code but to the rest of your development organization.

When starting a new project, most developers make sure that testing is a priority. However, only the lucky few live in the idyllic world of greenfield development; the vast majority of us must contend with code written when "test" was a four letter word and testing was the sole responsibility of that "other" organization. We'll examine some techniques for introducing testing - not just to your code but to the rest of your development organization.

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.

By Nathaniel Schutta

It seems that software follows the second law of thermodynamics - in other words, code tends towards disorder. Of course it doesn't have to be that way, and we have a number of tools and techniques that we can apply to keep our code in tip top shape. This talk will discuss ten things you can do to fight back!

It seems that software follows the second law of thermodynamics - in other words, code tends towards disorder. Of course it doesn't have to be that way, and we have a number of tools and techniques that we can apply to keep our code in tip top shape. This talk will discuss ten things you can do to fight back!

By Nathaniel Schutta

We all know that code can have a certain...odor but frankly so can projects. Everyone has their favorite horror story or tale of a death march. In this talk, we'll discuss common project smells and what you as a developer can do to maintain your sanity - and your hair line!

We all know that code can have a certain...odor but frankly so can projects. Everyone has their favorite horror story or tale of a death march. In this talk, we'll discuss common project smells and what you as a developer can do to maintain your sanity - and your hair line!

By Brian Sletten

There is a shift going on in the Enterprise. While still used and useful, the promises of the SOAP/WSDL/UDDI Service-Oriented Architecture (SOA) stack have failed to live up to their promise. A new vision of linked information is enveloping online and Enterprise users. The REST architectural style is squarely behind this thinking as a way of achieving low-cost, flexible integration, increased data security, greater scalability and long-term migration strategies.

If you have dismissed REST as a toy or are unfamiliar with it, you owe it to yourself to see what is so interesting about this way of doing things.

There is tremendous interest in REpresentational State Transfer (REST) as an architectural style for building scalable, flexible, information-driven architectures in the Enterprise. The success of the Web has caught our attention in the face of increased complexity and many failures with more traditional Web Services technologies. The problem is that it is difficult to sell a way to do things. Managers do not want to feel like they are innovating in the middleware space. They want to understand why they should deviate from the blue prints laid down by the industry leaders. They want to understand when they should use REST, when they should use SOAP and when they might fallback to regular old Java-based messaging. They want to make business-based technology decisions that lay a path to forward progress rather than paying for technological flux.

This talk will introduce REST and walk through why it is so important and makes such a difference. We will talk about REST API design, security, long-lived systems, content-negotiation, contract enforcement, when REST might not make sense, etc.

REST and the Web Architecture are the basis for many exciting things happening on the Web and within our organizations. You owe it to yourself to make sure you really "get it".

This talk should be accessible to everyone but is probably intermediate level.

By Brian Sletten

If you have started to take a look at REST as way of exposing web services or managing information spaces, you may be frustrated by the support offered by legacy containers. There is no direct support for REST concepts in the J2EE specs (yet). XML-based configurations are so 1990's. Come learn about Restlets, a little API that has caught the attention of many in the RESTafarian community.

The Restlet API was created by a guy who wanted object-level support for RESTful concepts, but didn't want to make the move to an advanced resource-oriented environment like NetKernel. He wanted his REST and conventional environments too. He also wanted a path to more modern containers that aren't tied to a blocking I/O model like the Servlet spec is.

This talk will include a brief review of REST and its primary concepts and will then provide an introduction to the Restlet API and how it supports these ideas. It will then focus on standing up a REST-oriented infrastructure using the Restlet API and a variety of other open source tools to support a publish/find/bind infrastructure without touching SOAP/WSDL/ or UDDI.

This talk will not try to convince you about using REST. If you aren't familiar with the concepts or want convincing, please come to the "REST" talk first.

Prerequisite: REST (unless you are very comfortable with REST)

By Brian Sletten

How well do you understand the dynamics of your applications? In our systems, we detect when simple things happen. Customers log in, people buy things, a stock is sold at a particular price, inventory shifts locations... all of these events mean little things, but what about the larger picture? Complex events are particular patterns of simpler events that suggest something deeper is happening. Do you know how you'd discover these bigger picture occurrences? Come hear how the Esper open source software represents a new class of complex event processing (CEP) frameworks that can be added to even high volume, high transaction systems.

Trying to write software to track event occurrence is difficult to do correctly and almost impossible to do efficiently. The problem is that the higher volume and performance our systems get, the harder it becomes and the more important it is to highlight interesting or unexpected activity that isn't represented simply by a log entry.

Complex Event Processing (CEP) and Event Stream Processing (ESP) systems are emerging as a new strategy for processing and detecting complex sequences of more rudimentary events that could have bigger implications to your production systems. While commercial software is starting to add this behavior, Esper represents one of the most accessible and widely-used frameworks for adding CEP/ESP capabilities to Java applications.

By Brian Sletten

You're a good Java programmer. You understand the JDK libraries and how to use them. The problem is that many fundamental APIs don't take the bigger performance picture in mind. Garbage collection can end up killing your app if you aren't careful. Concurrency problems and contention can keep your well-intentioned software from leveraging modern hardware architecture that support multi-core and multi-cpu systems.

Who knew that simply using the standard library code the way it was designed was opening you up for performance problems in your apps?

Don't worry, Javolution has your back.

Javolution is a small (300K) API designed to bring many of the benefits of the Real-Time Java Specification (RTJS) to J2SE, J2ME, GCJ and CLDC through deliberate design decisions.

It includes re-implementations of the java.util, java.lang, java.text, java.io and java.xml to demonstrate time-deterministic behavior. It also includes a framework for testing its own performance, supporting parallel computing, communicating with C/C++ applications and a real-time object to XML marshalling framework.

Come see how you can get some of the time-determinism and concurrency benefits in either your client or server side applications. This is a fairly deep talk and is largely a decomposition of an API that changes the runtime characteristics of the VM's runtime performance with only the tools offered by the language and the VM.

By Jeff Scott 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 Scott 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 Scott 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 Scott 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 Venkat Subramaniam

Java has been around for well over a decade now. It started out with the goal of being simple. Over the years, its picked up quite a bit of features and along comes complexity. In this presentation we will take a look at some tricky features of Java, those that can trip you over, and also look at some ways to improve your Java code.

Java features Set of tricks Tips to improve your Java code

By Venkat Subramaniam

The first item in the Agile Manifesto reads that we must prefer "people and interaction over process and tools." Given a choice between average people with superior tools and superior people with average tools, you are likely to achieve greater success with the latter. However, it is important to be continuous and not be episodic?so you want to get continuous feedback about the state, health, and quality of your code and application. Tools can help us a great deal to realize this and make us productive.

In this presentation we will take a look at tools (and their relevance and value) that can help smoothly execute your projects.

By Venkat Subramaniam

A good design is critical for success with agile development. That does not mean a big up-front design. The design has to be evolutionary. However, the design you evolve must be extensible and maintainable. After all, you can't be agile if your design sucks.

In this presentation, we will address what evolutionary design is, and will delve into principles and practices that can help realize an effective evolutionary design.

By Venkat Subramaniam

We all have seen our share of bad code. We certainly have come across some good code as well. What are the characteristics of good code? How can we identify those? What practices can promote us to write and maintain more of those good quality code. This presentation will focus on this topic that has a major impact on our ability to be agile and succeed.

Characteristics of quality code Metrics to measure quality Ways to identify and build quality

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

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

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

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

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

By Stuart Halloway

Dispatch takes many forms. Single dispatch, switch statements, pattern matching, and multiple dispatch all meet similar needs: Selecting runtime behavior in response to varying runtime conditions. Flexible dispatch is a key element of Java.next. All of the Java.next languages support dispatch strategies that are far more flexible than Java's single dispatch. In this talk (Part 3 of the Java.next series), I will explore how the Java.next languages (Clojure, Groovy, JRuby, and Scala) support dispatch.

For more information, see http://blog.thinkrelevance.com/2008/8/26/java-next-3-dispatch-2.

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

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

Although there are many books about agile, but few provide a path for guiding you through the beginning of an agile project. Whether you are preparing for your first agile project, or taking the lead for the first time, this session will provide a guided tour filled with practical advice and a pile of anecdotes.

We will start with things to do to prepare for the first iteration: assessments, project chartering, setting up a lab, iteration 0 and creating your first backlog. From there we will move into coaching practices like fostering discussions, facilitating retrospectives, social radiators, developer manifestos, talking in tests, and more. These are the techniques that will help you lead and successfully guide a newly forming agile community.

By David Hussman

Once your agile project is rolling along, there are many bumps and roadblocks which can derail the train. Whether you are leading the project formally or informally, there are techniques you can use to keep the project alive and innovative. This session will cover skills and techniques for leading sustainable project communities.

We will walk through some basics which need to be in place and then we will move on to advance topics like maintaining a living backlog, adapting to change, growing meaningful metrics, radiating information, working with project members, anti-coaching and more. We will also discuss a collection of monitors (spontaneous pairing, ?us? and ?them?, presence of pride, emergence of leaders) used by working coaches to determine which practices to use.

Prerequisite: Leading Agile Projects: Finding Your Groove in the First 4 Iterations

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

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

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

The Eclipse IDE has matured over several years to become quite a powerful tool with a robust plugin-based architecture. It gives commercial IDEs such as IDEA a run for their money. Yet, most developers barely scratch the surface of its capabilities. This talk will expose you to features that will greatly enhance your productivity. You will learn tips and tricks that will make you more efficient in your development activities and allow you to focus on solving the business problem at hand. Along the way you will be introduced to improvements introduced by the recent Galileo release.

.

By Srivaths Sankaran

Unsuccessful projects dominate the landscape of IT projects by a wide margin. Retrospectives are common occurrences and the advent of newer project delivery techniques hasn't proven to be the miracle cure. Some projects have lemon written all over them at the time of arrival and others just wither away for want of proper care and feeding.

This talk introduces you to a variety of project problems and how to address them. You will learn techniques that will get you off on the right foot and habits that will ensure smooth progress throughout the project's lifecycle. The net result will be a project that hits its target and a customer that is happy.

.

By Vladimir Vivien

This presentation is about JMX and Groovy. It shows how easy it is to insert runtime manageability into your application when you combine the JMX API with the flexibility of the Groovy scripting language. The Java Management Extension (JMX) provides the infrastructural layer for runtime management while Groovy provides the syntactical substrate in which you can readily express class instrumentation for management. The presentation takes an exploratory look at how Groovy can help script JMX and its constituencies including interacting with the MBean Server, exposing MBeans, using the Server Connector API, and sending JMX events to registered listeners.

Starting with the Java 5 programming language, it has gotten easier to incorporate monitoring and manageability into any application running on a standard VM. Developers now have access to a wealth of runtime profiling information exposed through Java Management Extensions (JMX), including memory consumption, garbage collection, and thread activities (and JSR77-compliant app servers expose standard enterprise management components). Using JMX API and the scripting power of Groovy, developer can easily inject runtime management and control capabilities into their own applications.

This presentation is about JMX and Groovy. It shows how easy it is to insert runtime manageability into your application when you combine the JMX API with the flexibility of the Groovy scripting language. The Java Management Extension (JMX) provides the infrastructural layer for runtime management while Groovy provides the syntactical substrate in which you can readily express class instrumentation for management. The presentation takes an exploratory look at how Groovy can help script the different JMX constituencies including interacting with the MBean Server, exposing MBeans, using the Server Connector API, and sending JMX events to registered listeners. The presentation includes several examples including applications that can react to JMX events. Of course, wherever there's Groovy, there must be Grails. You will see a practical application of management scripting applied to a demo Grails application.