#learninggroovy

I just back from Gr8Conf in Minneapolis last week and I had a great time. In case you missed it, I led a three hour workshop on Groovy and the slides and code are available (I did some practice screen-casts on youtube as well). Although I was pretty nervous leading up to it, I think it went really well. To those who attended: Thank you for listening and asking such great questions, I hope you enjoyed it! This was my first such workshop and everyone was super nice, so thank you again. I look forward to doing talks and/or workshops again in the future.

There were tons of great talks at Gr8Conf and although I didn’t get to go to all of them (I wish I could) I learned a lot and loved the energy from the conference in general. The “hallway discussions” and lunches were great as well. 

In other news, “Learning Groovy” is now featured on the official Groovy website, and was featured in “Groovy Calamari”! I can’t stress enough how thrilled I am about this!  Meanwhile, thank you to my company the SDG for supporting me in all these endeavors as well as just being a great company.

Modern Java: Second Edition is still in the works and I’ve expanded it to include Java 9. I’m sorry this one has been in production for so long. I hope to get it wrapped up before the final release of Java 9 in September. :-) There’s been a lot going on in the past year ...but I won’t make excuses. The good thing is the final product is going to be great. With all the new stuff in Java 9, plus more experience with Java 8 and other things, it should be interesting. I’m also mulling over next books, but nothing to announce yet.

I met and talked with tons of people at Gr8Conf, but one in particular is Eric Helgeson @nulleric. If you’re at all interested in Grails 3, check out his book, Practical Grails 3. The cool thing about it is he’s selling his book completely on his own and the book covers the app he wrote to sell the book.

Also, I’m still working on GrooCSS and have tons of ideas for it.

Last week I finally finished Learning Groovy and sent it on to publishing. It’s been a long process. Hopefully it’s mostly right. ;)

You can now purchase Learning Groovy in the following ways:

- Paperback on Amazon.

- Kindle on Amazon

- Paperback on Createspace.

- And of course, Leanpub: Learning Groovy

At its core, Ratpack enables asynchronous, stateless HTTP applications. It is built on Netty, the event-driven networking engine. Unlike many other web framework, there is no expectation that one thread handles one request. Instead, you are encouraged to handle blocking operations in a way that frees the current thread thus allowing high performance. (It has an implementation of Promise, and other classes to handle non-callback, asynchronous programming)

Ratpack can be used to make responsive, RESTful microservices, although it's not a requirement.

Unlike Grails and other popular web frameworks, Ratpack aims not to be a framework, but instead a set of libraries. (It has a plugin for Gradle, but any build tool could be used)

Although it's a lean set of libraries, Ratpack comes packed with support for JSON, websockets, SSE (Server Sent Events), SSL, SQL, logging, Dropwizard Metrics, newrelic, health checks, hystrix and more. (These are included as ratpack-* libraries, eg. ratpack-hystrix)

Ratpack uses Guice by default for DI (dependency injection). You can use Spring Boot instead.

[ Excerpt from: Learning Groovy ]

In Groovy you can override operators simply by naming your methods using the English word for the operator.

For example `plus` for + and `minus` for -.

Operator | Method-name

+ | plus

- | minus

* | multiply

/ | div

% | mod

** | power

|   | or

& | and

^ | xor

<< | leftShift

>> | rightShift

++ | next

-- | previous

All of these methods have one parameter except for "next" and "previous" which have no parameters.

For example, let's create a class called Logic with a boolean value and define the `and` and `or` methods.

class Logic {    boolean value    Logic(v) {this.value = v}    def and(Logic other) {            this.value && other.value    }    def or(Logic other) {           this.value || other.value    } }

Then let's use these methods and see if they work like you would expect:

def pale = new Logic(true) def old = new Logic(false)

println "groovy truth: ${pale && old}" println "using and: ${pale & old}" println "using or: ${pale | old}"

You'll notice that using the built-in && operator uses "Groovy truth" and returns true because both variables are non-null.

Next let's try out defining the `leftShift` and `minus` operators on a class:

class Wizards {    def list = []    def leftShift(person) { list.add person }    def minus(person) { list.remove person }    String toString() { "Wizards: $list" } } def wiz = new Wizards() wiz << 'Gandolf' println wiz wiz << 'Harry' println wiz wiz - 'Harry' println wiz

You can also implement map-like `putAt` and `getAt` methods as demonstrated in the next section. This allows you to use the bracket syntax, for example: