The Integrate Button website (from Paul Duvall’s book on Continuous Integration) recently published a screencast on using the Hudson Continuous Integration server - along with Subversion, Ant, HSQL and other tools. Click the image below to get started.

The screencast demonstrates the following steps:

• Checkout source files from the Subversion repository - locally
• Run the automated build locally
• Commit files to Subversion
• Download, install and configure Hudson - from Hudson website or from IntegrateButton scripts
• Make a code change (with error) and checkin files
• Get notified of error, automatically, via Hudson
• Fix code errors, commit change and see results in Hudson

It can be a significant burden to manually apply upgrades to an existing database. Moreover, it’s often an error-laden activity. IBM developerWorks’ recently published an article on this topic for Paul Duvall’s (Stelligent CTO) popular Automation for the people series called Hands-free database migration.

Databases are often out of sync with the applications they support, and getting the database and data into a known state is a significant challenge to manage. Learn how the open source LiquiBase database-migration tool can reduce the pain of managing the constant of change with databases and applications.

Authors Christopher Judd, Joseph Faisal Nusairat and Jim Shingler are getting beginners started with Groovy and Grails, taking a practical approach to teaching how to develop productive Grails web applications. Covering all the basics and some advanced topics of the Groovy language that is necessary for Grails application development, readers are guided through the process of writing a fully featured web application.

Everyone wanting to discover and use Groovy and Grails will gain the insight and skills needed to start creating their own applications.

The main highlights of this book are:
# Full coverage of basic Grails features of scaffolding, domains, controllers, services, and Groovy Server pages
# Tackles common web application challenges such as security, Ajax, web services, reporting, batch processing, and deployment
# Includes a Swing desktop client built in Groovy that integrates with the application using the exposed web services

Who should read this book
This book is for Java developers and organizations looking to become more productive by taking advantage of dynamic languages and solid agile web frameworks while lever-aging current investments in infrastructure, code, and education in the Java platform. It is for those who want to build internal applications and mission-critical, Internet-facing applications.
This book does not assume the reader has a strong Java or Groovy background, so those familiar with other dynamic languages like Perl, Ruby, Python, or PHP will find this a great source for investigating the Groovy and Grails alternative.

How This Book Is Oragnized
In this book, you’ll explore how to build command-line, Swing, and web applications using the Groovy language and the Grails web framework. The step-by-step approach will take you from a simple to a complex and fully featured Web 2.0 application. Chapters 1–3 provide a basic Groovy language primer, while Chapters 4–12 explain how to build and deploy web applications using Grails. The final chapter explains how to use Groovy and Swing to build a desktop client that interacts with the Grails web application.

You can find more information, table of contents and sample chapter online here: http://www.apress.com/book/view/1430210451

Downloading the Code
The code for the examples in this book is available to readers in the Source Code/Download section of the Apress web site at http://www.apress.com or on the book’s website at http://www.beginninggroovyandgrails.com.

DZone/Javalobby has over the past few months published several Refcardz which provide tips and tricks at your finger tips. I myself have been using many of these for the past several months. These Refcardz are written by industry experts, who in many cases are authors of best selling books. If you print these PDF versions, they look just great in your office as well.

Some of the cheat sheets I have found very useful are:

1. Getting Started with Eclipse includes :

• Getting Eclipse
• Workbench 101
• Development with Eclipse
• Keyboard Shortcuts
• Plug-ins
• Community Web Sites
• Hot Tips and more…

2. Spring Configuration topics covered:

• XML elements available as of Spring 2.5
• Most commonly used elements
• Namespaces
• Guide to Spring’s rich set of annotations

3. Dependency Injection in EJB3 includes:

• What is EJB3?
• Resource Injection
• Injection of EJB References
• Injecting JPA Resources
• Injecting Spring Beans in EJB 3
• Hot Tips and more…

4. Design Patterns covers the following:

• Chain of Responsibility
• Command
• Interpreter
• Iterator
• Mediator
• Observer
• Template Method and more..

5. IntelliJ IDEA includes:

• About IntelliJ IDEA
• Getting Yourself Oriented
• Finding What You Need
• Running and Debugging Your Project
• Write Less Code
• Hot Tips and more…

6. GlassFish Application Server covers the following topics:

• About GlassFish
• Installing GlassFish
• GlassFish Domains Profile
• Common Administration Tasks
• Clustering and Load Balancing
• Hot Tips and more…

There are many more available at the following site:

7. RefCardz at DZone

P.S: Before you can download any of these free PDF versions, you need to fill out a registration form; the form is really short.

Here is a sneak peek at Eclipse cheatsheet:

I don’t always agree with Mr. Yegge, but this is a great presentation/script on Dynamic Languages with some very interesting ideas and discussion topics.

One point that he never actually got to, but one that I think is worth more discussion - how do you maintain a million-line codebase w/out static types?

My answer is that with a good dynamic language, you have some seriously elegant features and patterns that allow you to keep the size of your codebase small.  Essentially, you don’t maintain a million-line codebase - because it doesn’t take a million lines to write your application.

Which fits in with some of the agile concepts as well - if you are building a project in an agile style, the constant refactoring and removal of technical debt will keep the application smaller and lighter.  The unit tests ensure a clean level of separation of concerns, the DRY and YAGNI principles reduce bloat.

On Wednesday evening, I had the pleasure of attending the Jolt Awards ceremony where Continuous Integration: Improving Software Quality and Reducing Risk was a finalist….and WON for best technical book!

Stelligent’s own, Paul Duvall, and co-author, Steve Matyas were on to hand to accept the trophy- which is essentially a giant can of Jolt cola encased in a Lucite block. You have to see it in person- the design is very cool (and it’s heavy!).

Many congratulations to Paul, Andy, and Steve; as well as the contributors, editors, and publishers who brought this book to life! This year’s winners will be featured in the June 2008 issue of Dr. Dobb’s Journal.

If you’re a fan of Continuous Integration (and local to the Washington DC area) you’ll want to clear your calendar the evening of Thursday, August 30th to celebrate with the authors of “Continuous Integration: Improving Software Quality and Reducing Risk” at their book signing.

Book signing at Barnes and Noble (map)
with Paul Duvall, Andrew Glover, and Steve Matyas
Thursday, August 30th
7:30 - 9:00 p.m.

Immediately following the signing, Stelligent and 5AM Solutions are throwing a release party at McCormick & Schmick’s. So…if the book isn’t enough to get you out of the house, the complimentary drinks and appetizers should.

Release party at McCormick & Schmick’s
Reston Town Center
9:00 - 11:00 p.m.

If you’re interested, please make sure to RSVP prior to August 27th. Oh, and feel free to spread the word, far and wide!

The release date for the newest addition to Addison-Wesley’s renowned Martin Fowler Signature series, Continuous Integration: Improving Software Quality and Reducing Risk, is just around the corner.

Authored by Paul Duvall, with co-authors Andrew Glover and Stephen Matyas, the book is available for pre-order to be shipped June 29, 2007.

If you’ve noticed that you’d rather be developing software for users rather than fiddling with software integration issues, this book will help you get there without much of the “pain” you thought would be involved.

Part I of the book provides an introduction to Continuous Integration (CI) including practices and techniques for using CI effectively with your teams. Part II expands the core concepts into other effective processes performed by CI systems, such as testing, inspection, deployment, and feedback.

If you haven’t already, I encourage you to head on over to Amazon to pre-order a copy (or three). Prepare to be spoiled.