Groovy 1.8 update - Guillaume Laforge - GR8Conf Europe 2011

Groovy Update
What’s new in Groovy 1.8
and what’s coming next!

Guillaume Laforge
Groovy Project Manager
SpringSource / VMware

mercredi 18 mai 2011

Guillaume Laforge

• Groovy Project Manager
• JSR-241 Spec Lead
• Head of Groovy Development
at SpringSource / VMWare
• Initiator of the Grails framework
• Creator of the Gaelyk toolkit
• Co-author of Groovy in Action

• Speaker: JavaOne, QCon, JavaZone, Sun TechDays,
Devoxx, The Spring Experience, SpringOne, JAX,
Dynamic Language World, IJTC, and more...

2

Groovy 1.7

3

Groovy 1.7

185
3

Groovy 1.7

185k
3

Groovy 1.7

185k FIRST MONTH
AFTER RELEASE
3

Groovy 1.7

k
3

Groovy 1.7

177k SECOND MONTH
AFTER RELEASE
3

Groovy 1.7

362k
USERS?
3

?
TIP OF
THE

ICEBERG

Agenda

•What’s new in Groovy 1.8?
– Nicer DSLs with command chains expressions
– Runtime performance improvements
– GPars bundled for taming your multicores
– Closure enhancements
– Builtin JSON support
– New AST transformations
– Miscelanous

5

Agenda

•What’s new in Groovy 1.8?
– Nicer DSLs with command chains expressions
– Runtime performance improvements
– GPars bundled for taming your multicores
– Closure enhancements
– Builtin JSON support
– New AST transformations
– Miscelanous

•What’s cooking for Groovy 1.9?
– Continued runtime performance improvements
– Alignments with JDK 7
•Project Coin (small language changes)
•InvokeDynamic
5

Command chains expressions

6


• A grammar improvement allowing you to
drop dots & parens when chaining method calls
– an extended version of top-level statements like println

6



• Less dots, less parens allow you to
– write more readable business rules
– in almost plain English sentences
•(or any language, of course)

6



• Less dots, less parens allow you to
– write more readable business rules
– in almost plain English sentences
•(or any language, of course)

• Let’s have a look at some examples

6


turn left then right

7


Alternation of
method names


7


Alternation of
method names


and parameters
(even named ones)

7


Equivalent to:

( ). ( )

7

LookM a!
N op are ns,
no do ts!



Before... we used to do...

take 2.pills, of: chloroquinine, after: 6.hours

9




Normal argument

9




Normal argument Named arguments

9




Normal argument Named arguments

Woud call:
def take(Map m, Quantity q)

9


Now, even less punctuation!

take 2.pills of chloroquinine after 6.hours

10


Now, even less punctuation!

( ). ( ). ( )

10


// environment initialization
Integer.metaClass.getPills { ‐> delegate }
Integer.metaClass.getHours { ‐> delegate }

// variable injection
def chloroquinine = /*...*/

{ }
// implementing the DSL logic
def take(n) {
    [of: { drug ‐>
        [after: { time ‐> /*...*/ }]
    }]
}

// ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

11



12



... some dots remain ...

12


We could cheat a bit...

take 2 pills of chloroquinine 6 hours after

13


We could cheat a bit...

( ). ( ). ( ). ( )
take 2 pills of chloroquinine 6 hours after

13

Cheating
is playing
with the
language



Still doable without cheating though

take 2 pills of chloroquinine after 6 hours

15


Still doable without cheating though

( ). ( ). ( ). ( )

15


// variable injection
def (of, after, hours) = /*...*/

// implementing the DSL logic

{ }
def take(n) {
    [pills: { of ‐>
        [chloroquinine: { after ‐>
            ['6': { time ‐> }]
        }]
    }]
}

// ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐

16


17


// methods with multiple arguments (commas)
take coffee with sugar, milk and liquor

17



// leverage named‐args as punctuation
check that: margarita tastes good

17




// closure parameters for new control structures
given {}  when {}  then {}

17





// zero‐arg methods require parens
select all  unique() from names

17






// possible with an odd number of terms
take 3  cookies

17


    (      ).    (           ).   (      )




take 3  cookies

17


    (      ).    (           ).   (      )

     (               ).      (    )



take 3  cookies

17


    (      ).    (           ).   (      )

     (               ).      (    )

     (  ).    (  ).    (  )


take 3  cookies

17


    (      ).    (           ).   (      )

     (               ).      (    )

     (  ).    (  ).    (  )

      (   ).        .    (     )

take 3  cookies

17


    (      ).    (           ).   (      )

     (               ).      (    )

     (  ).    (  ).    (  )

      (   ).        .    (     )

take 3  cookies
    ( ).

17

Runtime perf. improvements

• Significant runtime improvements
for primitive int operations
– classical Fibonacci example x13 faster!
– almost as fast as Java

• Some direct method calls on this

• But there’s more to come!
– in particular for all the primitive types

• But Jochen «blackdrag»
will tell you more on that!

18

GPars bundled

• GPars is bundled in the Groovy distribution

• GPars covers a wide range of parallel and
concurrent paradigms
– actors, fork/join, dataflow, agents, STM...

• Václav Pech will cover the details on GPars

19

Closure enhancements

• Closure annotation parameters

• Some more functional flavor
– composition
– trampoline
– memoization

• Currying improvements

20

Closure annotation parameters

@Retention(RetentionPolicy.RUNTIME)
@interface Invariant {
    Class value() // a closure class
}

{ @Invariant({ number >= 0 })
class Distance {
    float number
    String unit
}

def d = new Distance(number: 10, unit: "meters")
def anno = Distance.getAnnotation(Invariant)
def check = anno.value().newInstance(d, d)
assert check(d)

21

Closure annotation parameters

@Retention(RetentionPolicy.RUNTIME)
@interface Invariant {
    Class value() // a closure class
}

{ @Invariant({ number >= 0 })
class Distance {
    float number     P oor-m
miss
Cont
Andr
racts
an’s G é’s talk!
    String unit Don’t
}

def d = new Distance(number: 10, unit: "meters")
def anno = Distance.getAnnotation(Invariant)
def check = anno.value().newInstance(d, d)
assert check(d)

21

Closure composition

def plus2 = { it + 2 }
def times3 = { it * 3 }

{ def times3plus2 = plus2 << times3
assert times3plus2(3) == 11
assert times3plus2(4) == plus2(times3(4))

{ def plus2times3 = times3 << plus2
assert plus2times3(3) == 15
assert plus2times3(5) == times3(plus2(5))

// reverse composition
{ assert times3plus2(3) == (times3 >> plus2)(3)
22

Closure trampoline

23

Closure trampoline

def factorial

factorial = { int n, BigInteger accu = 1G ‐>

    if (n < 2) return accu
    factorial.trampoline(n ‐ 1, n * accu)
}.trampoline()

assert factorial(1)    == 1
assert factorial(3)    == 1 * 2 * 3
assert factorial(1000) == 402387260...

23

Closure memoization

24

Closure memoization

def plus = { a, b ‐> sleep 1000; a + b }.memoize()

24

Closure memoization


assert plus(1, 2) == 3 // after 1000ms

24

Closure memoization


assert plus(1, 2) == 3 // return immediately

24

Closure memoization



24

Closure memoization



// at least 10 invocations cached
def plusAtLeast = { ... }.memoizeAtLeast(10)

24

Closure memoization




// at most 10 invocations cached
def plusAtMost = { ... }.memoizeAtMost(10)

24

Closure memoization




// at most 10 invocations cached
def plusAtMost = { ... }.memoizeAtMost(10)

// between 10 and 20 invocations cached
def plusAtLeast = { ... }.memoizeBetween(10, 20)

24

Currying improvements

25


// right currying
def divide = { a, b ‐> a / b }
def halver = divide.rcurry(2)
assert halver(8) == 4

25


// right currying
def divide = { a, b ‐> a / b }
def halver = divide.rcurry(2)
assert halver(8) == 4

// currying n‐th parameter
def joinWithSeparator =
    { one, sep, two ‐> one + sep + two }
def joinWithComma =
    joinWithSeparator.ncurry(1, ', ')
assert joinWithComma('a', 'b') == 'a, b'

25

Builtin JSON support

• Consuming

• Producing

• Pretty-printing

26


import groovy.json.*

def payload = new URL(
"http://github.../json/commits/...").text

def slurper = new JsonSlurper()
def doc = slurper.parseText(payload)

doc.commits.message.each { println it }

27



def json = new JsonBuilder()

json.person {
    name "Guillaume"
    age 33
    pets "Hector", "Felix"
}
println json.toString()

28



println JsonOutput.prettyPrint(
'''{"person":{"name":"Guillaume","age":33,''' +
'''"pets":["Hector","Felix"]}}''')

29



println JsonOutput.prettyPrint(
    '''{"person":{"name":"Guillaume","age":33,''' +
    '''"pets":["Hector","Felix"]}}''')

{
    "person": {
        "name": "Guillaume",

        "age": 33,
        "pets": [
            "Hector",

            "Felix"
        ]
    }
}

29

New AST transformations

• @Log • @Canonical
– @ToString,
• @Field – @EqualsAndHashCode,
– @TupleConstructor

• @AutoClone
• @InheritConstructor
• @AutoExternalizable

• @WithReadLock
• Controlling the execution
of your code • @WithWriteLock
– @ThreadInterrupt,
– @TimedInterrupt, • @ListenerList
– @ConditionalInterrupt

30

@Log

• Four different loggers can be injected
– @Log, @Commons, @Log4j, @Slf4j
• Possible to implement your own strategy

import groovy.util.logging.*

@Log
class Car {
    Car() {
        log.info 'Car constructed'

    }
}

def c = new Car()

31

@Log



@Log
class Car {
Guarded     Car() {
w/ an if         log.info 'Car constructed'

    }
}

def c = new Car()

31

@Log


Hackerg
@Log arten
class Car {     certified!
Guarded     Car() {
w/ an if         log.info 'Car constructed'

    }
}

def c = new Car()

31

@Field

• Surprising scoping rules in scripts
– variables are local to the run() method
– variables aren’t visible in methods
•although visually the variable is in a surrounding scope

• @Field creates a field in the script class

@Field List awe = [1, 2, 3]
def awesum() { awe.sum() }
assert awesum() == 6

32

Controlling code execution

• Your application may run user’s code
– what if the code runs in infinite loops or for too long?
– what if the code consumes too many resources?

33



• 3 new transforms at your rescue
– @ThreadInterrupt: adds Thread#isInterrupted checks
so your executing thread stops when interrupted
– @TimedInterrupt: adds checks in method and closure
bodies to verify it’s run longer than expected
– @ConditionalInterrupt: adds checks with your own
conditional logic to break out from the user code

33



• 3 new transforms at your rescue
– @ThreadInterrupt: adds Thread#isInterrupted checks
so your executing thread stops when interrupted
– @TimedInterrupt: adds checks in method and closure
bodies to verify it’s run longer than expected
– @ConditionalInterrupt: adds checks with your own
conditional logic to break out from the user code

• Also see compilation customizers later on
33

@ThreadInterrupt

@ThreadInterrupt
import groovy.transform.ThreadInterrupt

while (true) {

// eat lots of CPU
}

34


@ThreadInterrupt

@ThreadInterrupt

while (true) {

{     if (Thread.currentThread.isInterrupted())
        throw new InterruptedException() }
    // eat lots of CPU
}

34


@ThreadInterrupt

@ThreadInterrupt

while (true) {

{     if (Thread.currentThread.isInterrupted())
        throw new InterruptedException() }
    // eat lots of CPU
}

• Two optional annotation parameters available
– checkOnMethodStart (true by default)
– applyToAllClasses (true by default)

34


@TimedInterrupt

@TimedInterrupt(10)
import groovy.transform.TimedInterrupt

while (true) {
// eat lots of CPU
}

• InterruptedException thrown when checks indicate
code ran longer than desired

• Optional annotation parameters available
– same as @ThreadInterrupt
– value: for an amount of time duration
– unit: for the time duration unit (TimeUnit.SECONDS)

35

@ConditionalInterrupt

• Specify your own condition to be inserted
at the start of method and closure bodies
– check for available resources, number of times run, etc.
• Leverages the new closure annotation parameter
feature of Groovy 1.8

@ConditionalInterrupt({ counter++ > 2 })
import groovy.transform.ConditionalInterrupt
import groovy.transform.Field

@Field int counter = 0

100.times {
println 'executing script method...'
}
36

@ToString

• Provides a default toString() method to your types
• Available annotation options
– includeNames, includeFields, includeSuper, excludes

import groovy.transform.ToString

@ToString
class Person {
    String name
    int age
}

println new Person(name: 'Pete', age: 15)
// => Person(Pete, 15)

37

@EqualsAndHashCode

• Provides default implementations for equals() and
hashCode() methods

import groovy.transform.EqualsAndHashCode

@EqualsAndHashCode
class Coord {
int x, y
}

def c1 = new Coord(x: 20, y: 5)
def c2 = new Coord(x: 20, y: 5)

assert c1 == c2
assert c1.hashCode() == c2.hashCode()

38

@TupleConstructor

• Provides a «classical» constructor with all properties
• Several annotation parameter options available

import groovy.transform.TupleConstructor

@TupleConstructor
class Person {
    String name
    int age
}

def m = new Person('Marion', 3)

assert m.name == 'Marion'
assert m.age  == 3

39

@Canonical

• One annotation to rule them all!
– @Canonical mixes together
•@ToString
•@EqualsAndHashCode
•@TupleConstructor

• You can customize behavior by combining
@Canonical and one of the other annotations

40

@InheritConstructor

• Classes like Exception are painful when extended,
as all the base constructors should be replicated

class CustomException extends Exception {
    CustomException()                        { super()       }
    CustomException(String msg)              { super(msg)    }
    CustomException(String msg, Throwable t) { super(msg, t) }
    CustomException(Throwable t)             { super(t)      }
}

41

@InheritConstructor

• Classes like Exception are painful when extended,
as all the base constructors should be replicated

import groovy.transform.*

@InheritConstructors
class CustomException extends Exception {
    CustomException()                        { super()       }
    CustomException(String msg)              { super(msg)    }
    CustomException(String msg, Throwable t) { super(msg, t) }
    CustomException(Throwable t)             { super(t)      }
}

41

@WithReadLock, @WithWriteLock


class ResourceProvider {
    private final Map<String, String> data = new HashMap<>()

    @WithReadLock
    String getResource(String key) {
        return data.get(key)
    }

    @WithWriteLock
    void refresh() {
        //reload the resources into memory
    }
}

42

@WithReadLock, @WithWriteLock


class ResourceProvider {
    private final Map<String, String> data = new HashMap<>()

{     @WithReadLock
    String getResource(String key) {
        return data.get(key)
    }

{     @WithWriteLock
    void refresh() {
        //reload the resources into memory
    }
}

42

Miscelanous

• Compilation customizers
• Java 7 diamond operator
• Slashy and dollar slashy strings
• New GDK methods
• (G)String to Enum coercion

43

Compilation customizers

• Ability to apply some customization to the Groovy
compilation process

• Three available customizers
– ImportCustomizer
– SecureASTCustomizer
– ASTTransformationCustomizer

• But you can implement your own

44

Imports customizer

def configuration = new CompilerConfiguration()

def custo = new ImportCustomizer()
custo.addStaticStar(Math.name)
configuration.addCompilationCustomizers(custo)

def result = new GroovyShell(configuration)
.evaluate(" cos PI/3 ")

45

Applying an AST transformation

def configuration = new CompilerConfiguration()

configuration.addCompilationCustomizers(
    new ASTTransformationCustomizer(Log))

new GroovyShell(configuration).evaluate("""
    class Car {
        Car() {
            log.info 'Car constructed'
        }
    }
    log.info 'Constructing a car'
    def c = new Car()
""")

46

Secure AST customizer

Idea: Implement an «arithmetic shell»
Being able control what a user script is
allowed to do: only arithmetic expressions

• Let’s setup our environment
– some imports
– an import customizer to import java.lang.Math.*
– prepare a secure AST customizer

import org.codehaus.groovy.control.customizers.*
import org.codehaus.groovy.control.*
import static org.codehaus.groovy.syntax.Types.*

def imports = new ImportCustomizer().addStaticStars('java.lang.Math')
def secure = new SecureASTCustomizer()
...

47


...
secure.with {
// disallow closure creation
closuresAllowed = false
// disallow method definitions
methodDefinitionAllowed = false

// empty white list => forbid imports
importsWhitelist = []
staticImportsWhitelist = []
// only allow the java.lang.Math.* static import
staticStarImportsWhitelist = ['java.lang.Math'
...

48

...
// language tokens allowed
tokensWhitelist = [
PLUS, MINUS, MULTIPLY, DIVIDE, MOD, POWER, PLUS_PLUS,
MINUS_MINUS, COMPARE_EQUAL, COMPARE_NOT_EQUAL,
COMPARE_LESS_THAN, COMPARE_LESS_THAN_EQUAL,
COMPARE_GREATER_THAN, COMPARE_GREATER_THAN_EQUAL
]

// types allowed to be used (including primitive types)
constantTypesClassesWhiteList = [
Integer, Float, Long, Double, BigDecimal,
Integer.TYPE, Long.TYPE, Float.TYPE, Double.TYPE
]

// classes who are allowed to be receivers of method calls
receiversClassesWhiteList = [
Math, Integer, Float, Double, Long, BigDecimal ]
}
...
49


• Ready to evaluate our arithmetic expressions!

...
def config = new CompilerConfiguration()
config.addCompilationCustomizers(imports, secure)

def shell = new GroovyShell(config)

shell.evaluate 'cos(PI/3)'

• But the following would have failed:

shell.evaluate 'System.exit(0)'

50

Slashy and dollar slashy strings

• Slashy strings are now multiline
– particularly handy for multi-line regexs

• Dollar slashy string notation introduced
– a multiline GString with different escaping rules

def (name, date) = ["Guillaume", "May, 17th"]
def dollarSlashy = $/
    Hello $name, today we're ${date}
    $ dollar‐sign
    $$ dollar‐sign
     backslash
    / slash
   $/ slash
/$

51

New GDK methods

52

New GDK methods
// count
assert [2,4,2,1,3,5,2,4,3].count { it % 2 == 0 } == 5

52

New GDK methods
// count
assert [2,4,2,1,3,5,2,4,3].count { it % 2 == 0 } == 5

// count by
assert [0:2, 1:3] == [1,2,3,4,5].countBy{ it % 2 }
assert [(true):2, (false):4]
== 'Groovy'.toList().countBy{ it == 'o' }

52

New GDK methods
// count
assert [2,4,2,1,3,5,2,4,3].count { it % 2 == 0 } == 5

// count by

// min/max for maps with closures
def map = [a: 1, bbb: 4, cc: 5, dddd: 2]
assert map.max { it.key.size() }.key == 'dddd'
assert map.min { it.value }.value == 1

52

New GDK methods
// count
assert [2,4,2,1,3,5,2,4,3].count { it % 2 == 0 } == 5

// count by

// min/max for maps with closures
def map = [a: 1, bbb: 4, cc: 5, dddd: 2]
assert map.max { it.key.size() }.key == 'dddd'
assert map.min { it.value }.value == 1

// map withDefault()
def words = "one two two three three three".split()
def freq = [:].withDefault { k ‐> 0 }
words.each { freq[it] += 1 }

52

(G)String to Enum coercion

enum Color {
red, green, blue
}

53


enum Color {
red, green, blue
}

// coercion with as
def r = "red" as Color

53


enum Color {
red, green, blue
}

// coercion with as

// implicit coercion
Color b = "blue"

53


enum Color {
red, green, blue
}

// coercion with as

// implicit coercion
Color b = "blue"

// with GStrings too
def g = "${'green'}" as Color

53

What’s
cooking
for 1.9?

Groovy 1.9 roadmap

• Java 7 alignements: Project Coin
– binary literals
– underscore in literals
– multicatch
• JDK 7: InvokeDynamic

• Towards a more modular Groovy
• Rewritten Antlr 3 grammar (GSoC)
• Eclipse compiler to replace
the joint compiler?

• What else? Your call!
55

Binary literals

• We had decimal, octal and hexadecimal notations
for number literals

• We can now use binary representations too

int x = 0b10101111
assert x == 175

byte aByte = 0b00100001
assert aByte == 33

int anInt = 0b1010000101000101
assert anInt == 41285

56

Underscore in literals

• We can now also add underscores
in number literals for more readability

long creditCardNumber = 1234_5678_9012_3456L
long socialSecurityNumbers = 999_99_9999L
float monetaryAmount = 12_345_132.12
long hexBytes = 0xFF_EC_DE_5E
long hexWords = 0xFFEC_DE5E
long maxLong = 0x7fff_ffff_ffff_ffffL
long alsoMaxLong = 9_223_372_036_854_775_807L
long bytes = 0b11010010_01101001_10010100_10010010

57

Multicatch

• One block for multiple exception caught
– rather than duplicating the block

try {
/* ... */
} catch(IOException | NullPointerException e) {
/* one block to treat 2 exceptions */
}

58

Summary

ROCK!
59

Thank you!

e
aforg pment
ume L Develo
Guilla Groovy om
He ad of e@ gmail.c
glaforg rge
Email: @glafo
:
Twitter

60

Image credits
• Iceberg: http://hqworld.net/gallery/data/media/20/tip_of_the_iceberg.jpg
• Bicycle: http://drunkcyclist.com/gallery/main.php?g2_view=core.DownloadItem&g2_itemId=2131&g2_serialNumber=2
• Pills: http://www.we-ew.com/wp-content/uploads/2011/01/plan-b-pills.jpg
• Chains: http://2.bp.blogspot.com/-GXDVqUYSCa0/TVdBsON4tdI/AAAAAAAAAW4/EgJOUmAxB28/s1600/breaking-chains5_copy9611.jpg
• Cheating: http://fr.academic.ru/pictures/frwiki/67/Cheating.JPG
• Cooking: http://www.flickr.com/photos/eole/449958332/sizes/l/
• Oui nide iou: http://desencyclopedie.wikia.com/wiki/Fichier:Superdupont_we_need_you.jpg
• Guitar: http://www.lelitteraire.com/IMG/breveon323.jpg
• Trampoline: http://www.fitness-online.fr/images/trampoline-1-m.jpg
• Curry: http://www.pot-a-epices.com/wp-content/uploads/2009/02/curry1.jpg
• Slurp: http://www.ohpacha.com/218-532-thickbox/gamelle-slurp.jpg

61

Groovy 1.8 update - Guillaume Laforge - GR8Conf Europe 2011

Recomendados

Recomendados

Mais conteúdo relacionado

Semelhante a Groovy 1.8 update - Guillaume Laforge - GR8Conf Europe 2011

Semelhante a Groovy 1.8 update - Guillaume Laforge - GR8Conf Europe 2011 (6)

Mais de Guillaume Laforge

Mais de Guillaume Laforge (20)

Último

Último (20)

Groovy 1.8 update - Guillaume Laforge - GR8Conf Europe 2011