At long last, Making Java Groovy

I guess you could say it all started with Jason Rudolph.

In April of 2005, I decided to leave the training company where I worked (The Golden Consulting Group, which no longer exists) and go out on my own as an independent technical trainer. My one-person company is called Kousen IT, Inc., and if the old laptop in my office is still running you can even browse my website. The decision to go independent was a long time coming, but that is a story for another day. My story today is about the long, tangled process that eventually resulted in a book called Making Java Groovy, which goes to press next week from Manning Publications.

(Mandatory Hitchhiker’s Guide to the Galaxy reference: mine is a wholly remarkable book, containing much that is apocryphal, or at least wildly inaccurate, but still, a wholly remarkable book. Actually, I dearly hope it’s accurate, and I have lots and lots of test cases in the book’s GitHub repository to make sure.)

Shortly after I became an independent, I realized that there was no one to act as a filter between me and the general public. It sounds obvious, but at the time it was quite a surprise, and a scary one at that. After spending over 15 years in one company or another, suddenly my voice was the voice of the company, so whatever I said had direct impact on the company’s reputation.

As it turns out, that’s quite the incentive to stop talking. Instructors need that incentive, too. If you’ve ever been in a training class, you know that you should never let an instructor start talking. My job is to keep talking until you either agree or give up. 🙂

The beauty of being an independent, though, is that I don’t need anyone else’s permission to risk the entire company on a change in direction. If I think a new technology is seriously cool, I can dive in, hoping against hope that it will eventually become popular enough to bring in business. I just need to get good enough at it that I can offer training in it to handle that business.

In 2005, I was completely invested in the Java platform. I did training classes in all areas of Java, which at the time ranged from introductory courses to design patterns to EJBs (version 2.0 — shudder). The biggest event of 2005 to hit the Java world, however, was the introduction of Ruby on Rails.

Looking back, RoR was like a meteor striking planet Java, killing off many of the dinosaurs. I remember the first time I watched David Heinemeier Hansson‘s initial RoR screencast, where he wrote a complete blogging application in 15 minutes. Nowadays everybody makes screencasts, but at the time it was sufficiently unusual to be remarkable. He built the whole app, and it was dazzling, especially if you came from the Java world, where we would still be arguing over tools and technologies during the first 15 minutes.

In December of 2005, I bought the Ruby book (the pickaxe book in common parlance) and the Agile Web Development with Rails book and started digging in.

I readily admit now that it was rough going. Clearly to make progress in RoR I needed to learn Ruby, and even though all these testimonials said that Ruby was easy, I wasn’t prepared for it. I think I could learn it now without much difficulty, but at the time it was quite a transition. I plugged away at it for a few months in my spare time, but for a variety of reasons it just didn’t take.

In November of 2006, however, I happened to be teaching a Spring framework class in Philadelphia. That was one of my first Spring classes, and I was still getting used to the ideas behind it. I noticed, however, that the local Spring Users Group in Philly was hosting a meeting that week, and that the speaker was Jason Rudolph, and he was giving a talk on something called Grails.

That talk changed my life.

I told Jason this years ago, but I doubt he remembers. He may not even remember me, though he might. He was on the No Fluff, Just Stuff tour at the time and it was one of dozens of similar presentations he gave that year and the next, and that talk was part of the reason I started going to the NFJS events near Boston. I attended his talks each time and peppered him with questions. I also devoured his Getting Started with Grails book, available as a free download at InfoQ, which was the only real reference at the time. It was written using Grails version 0.4, if you can remember back that far.

Since I already was comfortable with Java, was really digging into Spring, knew something about Hibernate, and was familiar with the basic ideas from Ruby on Rails, I was the target audience for a Grails presentation. I immediately bought Groovy in Action, and was very pleasantly surprised that it was, and is, one of the best technical books I’ve ever read. I fell in love with Groovy back then, and suddenly coding was fun again.

I told all my training company clients that both Groovy and Grails were going to be huge. They asked me for course outlines, which I provided, and we waited for the requests to roll in. They stubbornly refused to do so for about three more years, but that, too, is another story.

After being a tech reviewer for a couple of Groovy books (including Scott Davis’s Groovy Recipes and Venkat Subramaniam’s Programming Groovy), I eventually built up enough expertise to want to write a book of my own. Through various machinations that I’ll detail in a later blog post, I eventually wound up at Manning, where the contract for Making Java Groovy was signed back in March of 2010.

Btw, the original contract still refers to the book as “Groovy in Practice”. That’s the book they were after, and I went along with the idea in order to get it sold, but I always prefered the current title.

That’s not quite true. We went through a phase where the book was going to be called “Groovy and Java: The Sweet Spots”. That abbreviated to GaJ, which didn’t really scan, so I suggested we change the name to “Java and Groovy: The Sweet Spots”, which abbreviated to JaG. That worked, and was even a TV show with Catherine Bell in it, so it was all good. In fact, even though we eventually changed the name to Making Java Groovy (abbreviated MJG, which isn’t even pronounceable, sigh), I still put all the meetings with my editor on my calendar as “JaG review”.

I have tons more to say (see what I mean about never letting an instructor start talking?), but this post has already gotten long, so let me tell you what’s coming:

1. The book is supposed to go to the printer next Tuesday (September 3), right after Labor Day. That’s when I plan to start a series of Silly Marketing Ideas (abbreviated SMI), mixed in with a few Serious Marketing Ideas (abbreviated SMI).

2. I will be at the NFJS event in Seattle September 7 and 8, where I’ll no doubt mention the book sooner or later.

3. I’m traveling from there to the wonderful SpringOne2GX conference in Santa Clara, September 10 to 12. We’re actually hoping to have advanced copies of Making Java Groovy available at the conference, which will be the first time anyone will see it in print. The phrase “woo hoo!!” comes to mind, but I’ll wait until it happens to believe it.

4. From SpringOne2GX I’m headed to the NFJS event in Boston on the weekend of September 13 to 14. Please drop by and say hello (world?) if you get a chance.

5. The week of September 17 to 20 my book will be featured at JavaRanch, and I’ll be answering questions (probably combined with some really bad jokes) in the forums there. Feel free to ask anything you like, though I prefer really easy questions mixed in with unbridled praise and adulation for the book. Or whatever.

6. At 10am on Monday morning, September 23, I’m giving a talk entitled “Making Java Groovy” (what an amazing coincidence!) at JavaOne in San Francisco. I’ve never been to JavaOne, but since my book is intended to appeal to Java developers in general, that seemed like an irresistible opportunity. Please, please, please if you’re at the conference please come to the talk. I’d hate to be showing cool Groovy demos to an empty room. I promise you I’ve added several hilarious figures to the presentation, so at least I’ve got that going for me. Which is nice.

During the entire time I hope to write lots of blog posts, partly because I’m so excited I can’t stand it, partly in my hopeless but wryly amusing quest to make my book the first Java/Groovy integration book to make the New York Times Best Seller list, partly because it’ll help me deal with all the massive fears and insecurities that have forced themselves to the surface as this all becomes real at last, and partly because hey, when am I ever going to do something like this again?

So life is happening to me right now, and I’m trying to get out ahead of it. I’ll apologize in advance for going a little overboard on the marketing side, but I promise to inject as much humor as possible into the process. I also promise that I’ll always tell the whole truth here, in my blog, so that no matter what you hear from other sources, I’ll make sure you are always in on the gags if you read them here.

My goals are (not in any particular order) to have fun, make some money, and show as many Java developers as possible how much easier their lives can be if they’re willing to mix some Groovy into their projects. At the very least, it ought to be a wild ride.

Oh, and thanks again, Jason. You’re actually the first person I mentioned in my Acknowledgements. Surprise! 🙂

2 responses to “At long last, Making Java Groovy”

  1. Congratulations on taking this to Press.
    I am hoping this book makes many Java developers convinced on groovy; all the joy of programming that it brings to Java platform. I have been using groovy for several years and I learned the fact that it is really very hard to convince Java Developers.

  2. I’d come to your JavaOne talk but nobody is willing to pay the airfare and conference fees for me to travel across the country.

    I am impressed by Groovy. I’ve been working with Java for a long time, and frankly I would have left the core language entirely if not for the fact that I have a mortgage payment and “Junior Software Developer” (which is what I would be at any company that doesn’t use Java) just doesn’t pay the bills like “Senior Java Developer”.

    I’ve been looking at Scala, Groovy, and Clojure. The introductory Scala posts are awesome, but once you get into complex code and extensive use of operator overloading and complex trait inheritance hierarchies it becomes hard to follow.

    So that leaves Groovy and Clojure to duke it out. Right now I love them both.

Leave a Reply

This site uses Akismet to reduce spam. Learn how your comment data is processed.