Groovy, to Infinity and Beyond - Groovy/Grails eXchange 2009

to Infinity
and Beyond
mercredi 9 décembre 2009

Guillaume Laforge

•Groovy Project Manager
– working on Groovy since 2003
• G2One ➜ SpringSource ➜ VMWare

• Initiated the creation of Grails

• Co-author of Groovy in Action

• Speaker: JavaOne, QCon, Devoxx, JavaZone,
SpringOne, JAX, DSL DevCon, Google I/O, and
many more...

Copyright 2009 SpringSource. Copying, publishing or distributing without express written permission is prohibited. 2

About the content

• This presentation was prepared with the examples
I’ve used in my article written for InfoQ
– http://www.infoq.com/articles/groovy-1-6

• And from the release notes I’ve prepared for
Groovy 1.7
– http://docs.codehaus.org/display/GROOVY/(draft)
+Groovy+1.7+release

• For more information, don’t hesitate to read those
two articles!


Groovy 1.7
for Christmas

• Groovy 1.7-RC-2
shall be released
today! (Dec. 9th)

• Groovy 1.7-final
should be with the
other presents under
your Christmas tree!
(Dec. 22nd)


Playing with Groovy

• You can play with
these examples
within the
Groovy Web Console
hosted on
Google App Engine
– Uses Groovy 1.7-RC-1

– http://groovyconsole.appspot.com


nd a
Ag e
• Past (Groovy 1.6)

• Present (Groovy 1.7)

• Future (Groovy 1.8+)


nd a
Ag e • Past (Groovy 1.6)
– Syntax enhancements
– Compile-time metaprogramming
– The Grape module system

– Miscelanous
•Runtime metaprogramming
additions
•Built-in JSR-223 scripting engine
•JMX Builder
•OSGi readiness


Multiple assignments

• Newly defined variables
– def (a, b) = [1, 2]
assert a == 1 && b == 2

• Typed variables
– def (int a, int b) = [1, 2]

• Assign to existing variables
– def lat, lng
(lat, lng) = geocode(‘Paris’)

• The classical ‘swap case’
– (a, b) = [b, a]


More optional returns

• Return value of last expression of the last if/else,
try/catch, switch/case statement

• def m1() { if (true) 1 else 0 }

• def m2(b) {
try {
if (b) throw new Exception()
1
} catch(any) { 2 }
finally { 3 }
}
assert m2(false) == 1 && m2(true) == 2

Compile-time
metaprogramming

• With metaprogramming, Groovy’s able to modify
the behaviour of programs... at runtime

• Groovy 1.6 introduced AST Transformations
– AST: Abstract Syntax Tree
– Ability to change what’s being compiled at compile-time!
•No runtime impact!
•Lets you change the semantics of your programs!
•Nice way of implementing patterns and removing boiler-
plate technical code

• Two kinds of transformations: global and local


AST Transformations
in Groovy 1.6

• Several transformations finds their way
– @Singleton — okay, not really a pattern :-)
– @Immutable, @Lazy, @Delegate
– @Newify
– @Category and @Mixin
– @PackageScope
– Swing’s @Bindable and @Vetoable
– Grape’s @Grab

• Let’s have a look at some of them


The @Singleton anti-pattern

• The evil Java singleton
– public class Evil {
public static final Evil instance =
new Evil();
privavte Evil() {}
Evil getInstance() { return instance; }
}
• In Groovy now:
– @Singleton class Evil {}

• A lazy version also:
– @Singleton(lazy = true) class Evil {}


@Immutable

• To properly implement immutable classes
– No mutators (state musn’t change)
– Private final fields
– Defensive copying of mutable components
– Proper equals() / hashCode() / toString() for
comparisons, or for keys in maps, etc.

– @Immutable class Coordinates {
Double lat, lng
}
def c1 = new Coordinates(lat: 48.8, lng: 2.5)
def c2 = new Coordinates(48.8, 2.5)
assert c1 == c2


@Lazy, not just for lazy dudes!

• When you need to lazily evaluate or instantiate
complex data structures for class fields, mark them
with the @Lazy annotation

– class Dude {
@Lazy pets = retrieveFromSlowDB()
}

• Groovy will handle the boiler-plate code for you!


@Delegate
Not just for managers!

• You can delegate to fields of your class
– Think multiple inheritance

– class Employee {
def doTheWork() { "done" }
}
class Manager {
@Delegate Employee slave = new Employee()
}
def god = new Manager()
assert god.doTheWork() == "done"

• Damn manager will get all the praise...


Grab a Grape

• Groovy Advanced Packaging Engine
– Helps you distribute scripts without dependencies
– Just declare your dependencies with @Grab
•Will look for dependencies in Maven or Ivy repositories

– @Grab( group = 'org.mortbay.jetty',
module = 'jetty-embedded',
version = '6.1.0' )
def startServer() {
def srv = new Server(8080)
def ctx = new Context(srv , "/", SESSIONS)
ctx.resourceBase = "."
ctx.addServlet(GroovyServlet, "*.groovy")
srv.start()
}

ExpandoMetaClass DSL

• Before
– Number.metaClass.multiply = { Amount amount ->
amount.times(delegate)
}
Number.metaClass.div = { Amount amount ->
amount.inverse().times(delegate)
}
• In Groovy 1.6
– Number.metaClass {
multiply { Amount amount ->
amount.times(delegate)
}
div { Amount amount ->
amount.inverse().times(delegate)
}
}

Runtime mixins

• Inject new behavior to types at runtime

– class FlyingAbility {
def fly() { "I'm ${name} and I fly!" }
}

class JamesBondVehicle {
String getName() { "James Bond's vehicle" }
}

JamesBondVehicle.mixin FlyingAbility

assert new JamesBondVehicle().fly() ==
"I'm James Bond's vehicle and I fly!"


Miscelanous

•JMX builder
– A new builder for easily exposing, interacting with JMX
beans, listening to event, defining timers, etc.
•OSGi
– Groovy’s JAR is already OSGi compatible by sporting the
right attributes in the manifest
•JSR-223
– An implementation of the javax.script.* APIs is now part
of Groovy by default
•Swing console
– Customizable graphical representation of results
– Clickable stacktraces and error messages
– Drag’n Drop, code indentation, add JARs to the classpath

nd a
Ag e • Present (Groovy 1.7)
– Inner classes
– Annotations
– Grape enhancements
– Power asserts
– AST viewer and AST builder
– Customize the Groovy Truth


AIC and NC

• AIC: Anonymous Inner Classes
NC: Nested Classes

• For Java-compatibility sake, we’re brining AIC / NC
support into Groovy
– copy’n paste compatibility? :-)

• Not much to see beyond the usual standard Java
AIC / NC concept


Annotations everywhere!

• Groovy supports of annotations since Groovy 1.5
– a couple minor differences, for instance for arrays

• In Groovy 1.7, you can add annotations on
– imports
– packages
– variable declarations

• Handy for Grape!

• Source-level annotations, available through the AST


Terser Grape

• Ability to put the @Grab annotation on imports!
– @Grab(group = 'net.sf.json-lib',
module = 'json-lib', version = '2.3',
classifier = 'jdk15')
import net.sf.json.groovy.*
def root = new JsonSlurper().parseText(...)

• Put @Grab on variable declarations and use the
shorter notation
– @Grab('net.sf.json-lib:json-lib:2.3:jdk15')
def builder =
new net.sf.json.groovy.JsonGroovyBuilder()


Grab resolver

• Dependencies aren’t always available in Maven’s
repository, so you may need to specify a different
place to search libraries
– before, one had to modify grapeConfig.xml

• Groovy 1.7 introduces a Grape resolver
– @GrabResolver(name = 'restlet.org',
root = 'http://maven.restlet.org')
@Grab(group = 'org.restlet',
module =' org.restlet', version='1.1.6')
import org.restlet.Restlet
// ...


Power Asserts

• Enhanced assert statement and output
– def energy = 7200 * 10**15 + 1
def mass = 80
def celerity = 300000000
assert energy == mass * celerity ** 2


AST transformations

• With Groovy 1.6 came AST transformations

• But...
– you need a deep knowledge of the Groovy internals
– it’s not easy to know what the AST looks like
– writing transformations can be pretty verbose

• Groovy 1.7 introduces
– an AST viewer
– an AST builder


AST Viewer


AST Builder

• Ability to build AST parts
– from a String
•new AstBuilder().buildFromString(''' "Hello" ''')

– from code
•new AstBuilder().buildFromCode { "Hello" }

– from specification
•List<ASTNode> nodes
= new AstBuilder().buildFromSpec {
block {
returnStatement {
constant "Hello"
}
}
}

Customize the Groovy Truth!

• Ability to customize the Groovy Truth by
implementing of method boolean asBoolean()

• Your own predicate
– class Predicate {
boolean value
boolean asBoolean() { value }
}

assert new Predicate(value: true)
assert !new Predicate(value: false)


nd a
Ag e • Future (Groovy 1.8+)
– Extended annotations
– DSL: command statements
improvements
– Pattern matching
– Parser combinators
– New MOP
– JDK 7
•Project Coin
•Simple closures for Java
•InvokeDynamic


Groovy 1.8
and beyond...

• Caution!

• The following features are still
subject to discussion, and may
very well never see
the light of day!


Groovy 1.8, end of 2010

• Plan to provide various runtime improvements to
make Groovy faster and faster

• Make Groovy more modular
– Probably using Grape’s module system
– Breaking Groovy into smaller JARs
•not everybody needs everything (JMX, SQL, Swing...)

• Align Groovy with JDK 7 / Java 7
– Review project coin proposals where it makes sense
– Incorporate / integrate with InvokeDynamic (JSR-292)
– Interoperate with Java simple closures


Extended annotations

• Go beyond Java 5,
and let annotations support more type parameters
– closures, lists, maps, ranges

• Possible use cases
– validation, pre- and post-conditions

– @Validate({ name.size() > 4 })
String name

– @PreCondition({ msg != null })
void outputToUpperCase(String msg) {
println msg.toUpperCase()
}


Command-expression
based DSL

• Groovy lets you omit parentheses for top-level
expressions, and mix named and non-named
arguments

• Idea: extend to nested/chained expressions
– send "Hello" to "Jochen"
send "Hello", from: "Guillaume" to "Jochen"
sell 100.shares of MSFT
take 2.pills of chloroquinine in 6.hours
every 10.minutes { }
given { } when { } then { }
blend red, green of acrylic


Pattern matching

• Structural pattern matching on PO(J|G)Os
• First experiments will be done as module
– if successful, likely integrated in core

• term.match { // or match(term) {}
Num(value) {}
Plus(left, right) {}
Num(value: 5) {}
Num(value > 0) {}
Plus(left: Plus(left: a, right: 2), right) {}
Plus(left: a, right: b) | Minus(left: a, right: b) {}
Object(left, right) {}
nothing { }
}


Parser combinators

• Same as pattern matching, experiments need to be
done as a module, before possible integration in
core
– Also need Groovy modularity to be implemented

• def language = grammar {
digit: ~/[0-9]/
letter: ~/[a-zA-Z]/
identifier: letter + ( letter | digit ){n}
number: digit{n}
}
grammar.parse(...)


nd a
Ag e
• Summary

• Questions & Answers


Summary

• Groovy, still inovative, since 2003!
– Newever versions always bring their share of new
features and libraries to simplify the life of the developer
– And there’s more to come!

• But Groovy’s more than just a language, it’s a very
active and lively ecosystem with tons of great
projects
– Grails, Gradle, GPars, Spock, Gaelyk, etc...

• Enjoy the conference!


Questions & Answers


Photo credits

• Buzz LightYear: http://bu77lightyear.files.wordpress.com/2008/09/buzzlightyear_high.jpg
• Christmas tree: http://www.thedailygreen.com/cm/thedailygreen/images/WT/christmas-tree-with-gifts-flipbook.jpg
• Caution: http://www.disastersuppliesusa.com/catalog/ee44.jpg
• Light bulb: https://newsline.llnl.gov/retooling/mar/03.28.08_images/lightBulb.png


Groovy, to Infinity and Beyond - Groovy/Grails eXchange 2009

Recommandé

Recommandé

Contenu connexe

Similaire à Groovy, to Infinity and Beyond - Groovy/Grails eXchange 2009

Similaire à Groovy, to Infinity and Beyond - Groovy/Grails eXchange 2009 (20)

Plus de Guillaume Laforge

Plus de Guillaume Laforge (20)

Dernier

Dernier (20)

Groovy, to Infinity and Beyond - Groovy/Grails eXchange 2009