In this first half of a two-part article focusing on memcached and Grails, author James Goodwill introduces you to the open source caching solution memcached. Topics covered in this article include installation, configuration, memcached client commands, and evaluating the effectiveness of your cache. Unlike articles about using memcached with a language-specific client, this one focuses on direct interaction with the memcached server. The goal is to give you the tools you need to monitor your instance of memcached as well as to prepare you for the second half of the article, in which you will integrate memcached into a Grails application.

This article shows you how to create your own Grails plug-in. Once you see how effortless it is to create a plug-in, you'll understand why more than 250 Grails plug-ins are available now, with new ones being added all the time.

Grails is a fantastic framework. As well as being ultra-productive and fun to work with, it encourages good testing practices, and provides a swathe of tools to make writing unit, integration, and web tests a real pleasure. As we will see, Grails also lends itself quite well to build automation. However, Grails is not Maven. Grails has a fairly loose concept of the software development lifecycle, and is happy to let you bundle up and deploy your application as a WAR file without running all the unit and integration tests first. A Continuous Integration (CI) server can help you keep the flexibility of the Grails development process, and still ensure that your code is fully tested for each and every code change. In this article, we will take a look at how you can introduce Continuous Integration into your Grails project. More specifically, we will walk through how you can automate your Grails testing and code quality metrics with Hudson, a popular open source CI tool.

David Dossot, co-author of Mule in Action, examines the power of Mule RESTpack and Groovy in orchestrating RESTful services in the Mule messaging platform.

Scott Davis continues the discussion about Groovy metaprogramming with an in-depth look at the @Delegate annotation, which blurs the distinctions between data type and behavior and static and dynamic typing.

Open source solutions and borrowed infrastructures are changing the character of Java™ development, letting you deliver better software quickly and at a low cost. Andrew Glover, coining the term Java development 2.0 to encapsulate the cumulative force of these phenomena, launches a new series on some of the relevant tools and technologies. This first installment heralds the arrival of Java development 2.0 and explains how you can bring its concepts to fruition quickly with Google's App Engine for Java.

In this Mastering Grails installment, Scott Davis introduces you to the world of Grails plug-ins. Adding whole areas of new functionality to your applications couldn't be easier. You'll learn how plug-ins do their magic, and you'll use a plug-in to implement powerful search capabilities in the Blogito application.

Enter into the world of metaprogramming, Groovy-style. The ability to add new methods to classes dynamically at run time — even Java™ classes, and even final Java classes — is incredibly powerful. Whether used for production code, unit tests, or anything in between, Groovy's metaprogramming capabilities should pique the curiosity of even the most jaded Java developer.

In the previous part of the article by Jon Dickinson, we saw how to construct a domain model to allow files and messages to be tagged. In this part, we will see how to customize our home page and work with the templates and tags

As with messages, files are displayed on the home page in the order they are added to the system. Currently all messages and files are displayed on the home page. Over time, our home page is going to become rather large and unwieldy. We need a user's home page to show only the files and messages that they are interested in. To do this, users need to be able to tag their content. The new Grails concepts that will be introduced in this two-part article series by Jon Dickinson are:
* Working with inheritance in the domain classes, and looking at which strategies GORM supports for persistence
* Using polymorphic queries over a domain inheritance hierarchy
* Encapsulating view-rendering logic in GSP templates
* Manipulating collections with the Groovy collect and sort methods