Groovy in 2014 and beyond at Devoxx France

@glaforge #dvxgroovy Groovy en 2014 et au-delà… Guillaume Laforge Groovy
Project Manager http://glaforge.appspot.com

Les Cast Codeurs

Les Cast Codeurs 18:05 Miles Davis

@glaforge #dvxgroovy Stay up-to-date with all things Groovy ! •
Groovy Weekly newsletter • Every Tuesday ! • http://bit.ly/groovy-weekly- subscribe

Groovy Google+ page ! • https://plus.google.com/ +groovy

Groovy Google+ community ! • https://plus.google.com/ communities/ 105160926044623621768

@YourTwitterHandle #DVXFR14{session hashtag} @glaforge #dvxgroovy A genda

@glaforge #dvxgroovy The Groovy roadmap… 2015 2014 2013

@glaforge #dvxgroovy The Groovy roadmap… 2015 2014 2013 Groovy 2.2

Groovy 2.2

Groovy 3.0 Groovy 2.2

@glaforge #dvxgroovy Groovy 2.3 • JDK 8 runtime support •
Traits • New and updates AST transformations • NIO2 module • JSON improvements & performance gains • New Markup template engine • Documentation overhaul

@glaforge #dvxgroovy Groovy 3.0 ! • New Meta-Object Protocol !
• Invoke-dynamic based runtime ! • Rewritten language grammar with Antlr v4

@YourTwitterHandle #DVXFR14{session hashtag} @glaforge #dvxgroovy G roovy 2.3

@YourTwitterHandle @glaforge #dvxgroovy JD K 8 support

@YourTwitterHandle @glaforge #dvxgroovy Traits

@glaforge #dvxgroovy Traits • Like interfaces, but with method bodies
• similar to Java 8 interface default methods • Elegant way to compose behavior • multiple inheritance, without the « diamond problem » • Traits can also be stateful • traits can have properties like normal classes • Compatible with static typing & compilation • class methods coming from traits are also visible from Java • Also possible to implement traits at runtime

@glaforge #dvxgroovy trait FlyingAbility { String
fly() { "I'm flying!" } } ! class Bird implements FlyingAbility {} def b = new Bird() ! assert b.fly() == "I'm flying!" Traits: a simple example

fly() { "I'm flying!" } } ! class Bird implements FlyingAbility {} def b = new Bird() ! assert b.fly() == "I'm flying!" Traits: a simple example « trait », a new keyword for a new concept

fly() { "I'm flying!" } } ! class Bird implements FlyingAbility {} def b = new Bird() ! assert b.fly() == "I'm flying!" Traits: a simple example a class   « implements »  a trait

fly() { "I'm flying!" } } ! class Bird implements FlyingAbility {} def b = new Bird() ! assert b.fly() == "I'm flying!" Traits: a simple example the fly() method from the trait is available

fly() { "I'm flying!" } } ! class Bird implements FlyingAbility {} def b = new Bird() ! assert b.fly() == "I'm flying!" Traits: a simple example

@glaforge #dvxgroovy trait Named { String
name } ! class Bird implements Named {} def b = new Bird(name: 'Colibri') ! assert b.name == 'Colibri' Traits: stateful

name } ! class Bird implements Named {} def b = new Bird(name: 'Colibri') ! assert b.name == 'Colibri' Traits: stateful a Groovy property

name } ! class Bird implements Named {} def b = new Bird(name: 'Colibri') ! assert b.name == 'Colibri' Traits: stateful implement the trait

name } ! class Bird implements Named {} def b = new Bird(name: 'Colibri') ! assert b.name == 'Colibri' Traits: stateful Groovy named argument constructor

name } ! class Bird implements Named {} def b = new Bird(name: 'Colibri') ! assert b.name == 'Colibri' Traits: stateful access the property

name } ! class Bird implements Named {} def b = new Bird(name: 'Colibri') ! assert b.name == 'Colibri' Traits: stateful

@glaforge #dvxgroovy trait Named { String name } !
trait FlyingAbility extends Named { String fly() { "I'm a flying ${name}!" } } ! class Bird implements FlyingAbility {} def b = new Bird(name: 'Colibri') ! assert b.name == 'Colibri' assert b.fly() == "I'm a flying Colibri!" Traits: inheritance

trait FlyingAbility extends Named { String fly() { "I'm a flying ${name}!" } } ! class Bird implements FlyingAbility {} def b = new Bird(name: 'Colibri') ! assert b.name == 'Colibri' assert b.fly() == "I'm a flying Colibri!" Traits: inheritance extend the Named trait

trait FlyingAbility extends Named { String fly() { "I'm a flying ${name}!" } } ! class Bird implements FlyingAbility {} def b = new Bird(name: 'Colibri') ! assert b.name == 'Colibri' assert b.fly() == "I'm a flying Colibri!" Traits: inheritance access the name property

trait FlyingAbility extends Named { String fly() { "I'm a flying ${name}!" } } ! class Bird implements FlyingAbility {} def b = new Bird(name: 'Colibri') ! assert b.name == 'Colibri' assert b.fly() == "I'm a flying Colibri!" Traits: inheritance implement the composite trait

trait FlyingAbility extends Named { String fly() { "I'm a flying ${name}!" } } ! class Bird implements FlyingAbility {} def b = new Bird(name: 'Colibri') ! assert b.name == 'Colibri' assert b.fly() == "I'm a flying Colibri!" Traits: inheritance

fly() { "I'm a flying $name!" } } ! trait Named { String name } ! class Bird implements Named, FlyingAbility {} def b = new Bird(name: 'Colibri') ! assert b.name == 'Colibri' assert b.fly() == "I'm a flying Colibri!" Traits: multiple inheritance (& dynamism)

fly() { "I'm a flying $name!" } } ! trait Named { String name } ! class Bird implements Named, FlyingAbility {} def b = new Bird(name: 'Colibri') ! assert b.name == 'Colibri' assert b.fly() == "I'm a flying Colibri!" Traits: multiple inheritance (& dynamism) access a dynamic property

fly() { "I'm a flying $name!" } } ! trait Named { String name } ! class Bird implements Named, FlyingAbility {} def b = new Bird(name: 'Colibri') ! assert b.name == 'Colibri' assert b.fly() == "I'm a flying Colibri!" Traits: multiple inheritance (& dynamism) implements two traits!

fly() { "I'm a flying $name!" } } ! trait Named { String name } ! class Bird implements Named, FlyingAbility {} def b = new Bird(name: 'Colibri') ! assert b.name == 'Colibri' assert b.fly() == "I'm a flying Colibri!" Traits: multiple inheritance (& dynamism) dynamic ‘name’ property interpolated

fly() { "I'm a flying $name!" } } ! trait Named { String name } ! class Bird implements Named, FlyingAbility {} def b = new Bird(name: 'Colibri') ! assert b.name == 'Colibri' assert b.fly() == "I'm a flying Colibri!" Traits: multiple inheritance (& dynamism)

@glaforge #dvxgroovy trait KiteSurfer { String surf() { 'kite' }
} ! trait WebSurfer { String surf() { 'web' } } ! class Person { String name } ! class Hipster extends Person implements KiteSurfer, WebSurfer {} ! def h = new Hipster() assert h.surf() == 'web' Traits: what about conflicts?

} ! trait WebSurfer { String surf() { 'web' } } ! class Person { String name } ! class Hipster extends Person implements KiteSurfer, WebSurfer {} ! def h = new Hipster() assert h.surf() == 'web' Traits: what about conflicts? two surf() methods

} ! trait WebSurfer { String surf() { 'web' } } ! class Person { String name } ! class Hipster extends Person implements KiteSurfer, WebSurfer {} ! def h = new Hipster() assert h.surf() == 'web' Traits: what about conflicts? extending a class and implementing the two traits

} ! trait WebSurfer { String surf() { 'web' } } ! class Person { String name } ! class Hipster extends Person implements KiteSurfer, WebSurfer {} ! def h = new Hipster() assert h.surf() == 'web' Traits: what about conflicts? last declared trait wins!

} ! trait WebSurfer { String surf() { 'web' } } ! class Person { String name } ! class Hipster extends Person implements WebSurfer, KiteSurfer {} ! def h = new Hipster() assert h.surf() == 'kite' Traits: what about conflicts?

} ! trait WebSurfer { String surf() { 'web' } } ! class Person { String name } ! class Hipster extends Person implements WebSurfer, KiteSurfer {} ! def h = new Hipster() assert h.surf() == 'kite' Traits: what about conflicts? reverse the order!

} ! trait WebSurfer { String surf() { 'web' } } ! class Person { String name } ! class Hipster extends Person implements WebSurfer, KiteSurfer {} ! def h = new Hipster() assert h.surf() == 'kite' Traits: what about conflicts?

} ! trait WebSurfer { String surf() { 'web' } } ! class Person { String name } ! class Hipster extends Person implements WebSurfer, KiteSurfer { String surf() { KiteSurfer.super.surf() } } def h = new Hipster() assert h.surf() == 'kite' Traits: what about conflicts?

} ! trait WebSurfer { String surf() { 'web' } } ! class Person { String name } ! class Hipster extends Person implements WebSurfer, KiteSurfer { String surf() { KiteSurfer.super.surf() } } def h = new Hipster() assert h.surf() == 'kite' Traits: what about conflicts? Be explicit! Override surf()   & use ‘super’

} ! trait WebSurfer { String surf() { 'web' } } ! class Person { String name } ! class Hipster extends Person implements WebSurfer, KiteSurfer { String surf() { KiteSurfer.super.surf() } } def h = new Hipster() assert h.surf() == 'kite' Traits: what about conflicts? Your class method takes precedence over the traits

} ! trait WebSurfer { String surf() { 'web' } } ! class Person { String name } ! class Hipster extends Person implements WebSurfer, KiteSurfer { String surf() { KiteSurfer.super.surf() } } def h = new Hipster() assert h.surf() == 'kite' Traits: what about conflicts?

@glaforge #dvxgroovy ! ! trait CustomToString { !
String toString() { "a ${this.class.name} instance" } } ! class Foo implements CustomToString {} ! assert new Foo().toString() != 'a Foo instance' Traits: forcing method override

String toString() { "a ${this.class.name} instance" } } ! class Foo implements CustomToString {} ! assert new Foo().toString() != 'a Foo instance' Traits: forcing method override ‘this’ is the ‘this’ of the class implementing the trait

String toString() { "a ${this.class.name} instance" } } ! class Foo implements CustomToString {} ! assert new Foo().toString() != 'a Foo instance' Traits: forcing method override The default Object#toString() method always prevails,   in spite of the trait’s toString()

String toString() { "a ${this.class.name} instance" } } ! class Foo implements CustomToString {} ! assert new Foo().toString() != 'a Foo instance' Traits: forcing method override

@glaforge #dvxgroovy import groovy.transform.ForceOverride ! trait CustomToString {
@ForceOverride String toString() { "a ${this.class.name} instance" } } ! class Foo implements CustomToString {} ! assert new Foo().toString() == 'a Foo instance' Traits: forcing method override

@ForceOverride String toString() { "a ${this.class.name} instance" } } ! class Foo implements CustomToString {} ! assert new Foo().toString() == 'a Foo instance' Traits: forcing method override Use @ForceOverride to force the compiler to use the trait’s method

@ForceOverride String toString() { "a ${this.class.name} instance" } } ! class Foo implements CustomToString {} ! assert new Foo().toString() == 'a Foo instance' Traits: forcing method override If Foo had implemented toString(), Foo’s toString() would always win

@ForceOverride String toString() { "a ${this.class.name} instance" } } ! class Foo implements CustomToString {} ! assert new Foo().toString() == 'a Foo instance' Traits: forcing method override

name } ! class Animal {} class NamedAnimal implements Named {} ! def na = new NamedAnimal(name: 'Felix') ! assert na.name == 'Felix' Traits: runtime implementation

name } ! class Animal {} class NamedAnimal implements Named {} ! def na = new NamedAnimal(name: 'Felix') ! assert na.name == 'Felix' Traits: runtime implementation Somewhat artificial to have to create an intermediary class to get named animals

name } ! class Animal {} class NamedAnimal implements Named {} ! def na = new NamedAnimal(name: 'Felix') ! assert na.name == 'Felix' Traits: runtime implementation

name } ! class Animal {} ! ! def na = new Animal() as Named na.name = 'Felix' assert na.name == 'Felix' Traits: runtime implementation

name } ! class Animal {} ! ! def na = new Animal() as Named na.name = 'Felix' assert na.name == 'Felix' Traits: runtime implementation Runtime trait,   with Groovy’s usual coercion mechanism

name } ! class Animal {} ! ! def na = new Animal() as Named na.name = 'Felix' assert na.name == 'Felix' Traits: runtime implementation

trait Quacks { String quack() { 'Quack!' } } ! class Animal {} ! def na = new Animal().withTraits Named, Quacks na.name = 'Daffy' assert na.name == 'Daffy' assert na.quack() == 'Quack!' Traits: runtime implementation

trait Quacks { String quack() { 'Quack!' } } ! class Animal {} ! def na = new Animal().withTraits Named, Quacks na.name = 'Daffy' assert na.name == 'Daffy' assert na.quack() == 'Quack!' Traits: runtime implementation Implement several traits at once, at runtime

trait Quacks { String quack() { 'Quack!' } } ! class Animal {} ! def na = new Animal().withTraits Named, Quacks na.name = 'Daffy' assert na.name == 'Daffy' assert na.quack() == 'Quack!' Traits: runtime implementation

@glaforge #dvxgroovy Traits: miscellaneous • Traits can… ! • have
private ﬁelds and methods • have abstract methods • implement interfaces • extend other traits or implement several traits • be statically type checked and compiled

@YourTwitterHandle @glaforge #dvxgroovy A ST transform s

@glaforge #dvxgroovy New: @TailRecursive import groovy.transform.TailRecursive ! @TailRecursive
def fact(BigInteger n, accu = 1G) { if (n < 2) accu else fact(n -‐ 1, n * accu) } ! assert fact(1000) > 10e2566

def fact(BigInteger n, accu = 1G) { if (n < 2) accu else fact(n -‐ 1, n * accu) } ! assert fact(1000) > 10e2566 Rewrites tail recursive friendly function serially

def fact(BigInteger n, accu = 1G) { if (n < 2) accu else fact(n -‐ 1, n * accu) } ! assert fact(1000) > 10e2566 Doesn’t blow up with a stack overflow error

def fact(BigInteger n, accu = 1G) { if (n < 2) accu else fact(n -‐ 1, n * accu) } ! assert fact(1000) > 10e2566 Downside of tail recursion is   you might have to rewrite   your algo to be tailrec friendly

def fact(BigInteger n, accu = 1G) { if (n < 2) accu else fact(n -‐ 1, n * accu) } ! assert fact(1000) > 10e2566

@glaforge #dvxgroovy New: @Sortable import groovy.transform.* ! @Sortable
class Person { String lastName String firstName int age }

class Person { String lastName String firstName int age } Makes the class Comparable by multiple Comparators

class Person { String lastName String firstName int age } First compare by lastName, then by firstName, etc.

class Person { String lastName String firstName int age } You can also specify ‘includes’ / ‘excludes’ properties

class Person { String lastName String firstName int age }

@glaforge #dvxgroovy @BaseScript improvements abstract class CustomBase extends Script {
int meaningOfLife = 42 } @BaseScript(CustomBase) import groovy.transform.BaseScript ! assert meaningOfLife == 42

int meaningOfLife = 42 } @BaseScript(CustomBase) import groovy.transform.BaseScript ! assert meaningOfLife == 42 You can add your own base methods and properties to all compiled scripts

int meaningOfLife = 42 } @BaseScript(CustomBase) import groovy.transform.BaseScript ! assert meaningOfLife == 42 Define the base script class for this script

int meaningOfLife = 42 } @BaseScript(CustomBase) import groovy.transform.BaseScript ! assert meaningOfLife == 42 In 2.3, ability to put the annotation on imports & package

int meaningOfLife = 42 } @BaseScript(CustomBase) import groovy.transform.BaseScript ! assert meaningOfLife == 42

@glaforge #dvxgroovy @BaseScript custom abstract method abstract class CustomBase extends
Script { def run() { before() internalRun() after() } ! abstract internalRun() ! def before() { println 'before' } def after() { println 'after' } }

Script { def run() { before() internalRun() after() } ! abstract internalRun() ! def before() { println 'before' } def after() { println 'after' } } import groovy.transform.BaseScript @BaseScript CustomBase script ! println 'Hello'

Script { def run() { before() internalRun() after() } ! abstract internalRun() ! def before() { println 'before' } def after() { println 'after' } } import groovy.transform.BaseScript @BaseScript CustomBase script ! println 'Hello' You can define your own abstract method for script bodies

Script { def run() { before() internalRun() after() } ! abstract internalRun() ! def before() { println 'before' } def after() { println 'after' } } import groovy.transform.BaseScript @BaseScript CustomBase script ! println 'Hello'

@YourTwitterHandle @glaforge #dvxgroovy N IO 2 m odule

@glaforge #dvxgroovy JDK 7+ NIO2 module • All the familiar
methods on File retroﬁtted on Path as well path.withReader { Reader r -‐> ... } path.eachLine { String line -‐> ... } path.eachFileRecurse { Path p -‐> ... } path << 'some content' path << bytes path.readLines() …

methods on File retroﬁtted on Path as well path.withReader { Reader r -‐> ... } path.eachLine { String line -‐> ... } path.eachFileRecurse { Path p -‐> ... } path << 'some content' path << bytes path.readLines() … Feature request to add all the java.nio.file.Files static utility methods as GDK methods

methods on File retroﬁtted on Path as well path.withReader { Reader r -‐> ... } path.eachLine { String line -‐> ... } path.eachFileRecurse { Path p -‐> ... } path << 'some content' path << bytes path.readLines() …

@YourTwitterHandle @glaforge #dvxgroovy JSO N

@glaforge #dvxgroovy JSON parser / builder performance increase • Re-implementation
of JSON support for speed & efﬁciency • parser forked of the Boon JSON project • serializer carefully ﬁne-tuned ! • Article on the parsing speed improvements • http://rick-hightower.blogspot.fr/2014/04/groovy-and-boon-provide-fastest-json.html

of JSON support for speed & efﬁciency • parser forked of the Boon JSON project • serializer carefully ﬁne-tuned ! • Article on the parsing speed improvements • http://rick-hightower.blogspot.fr/2014/04/groovy-and-boon-provide-fastest-json.html Benchmark gives 3x to 4x performance factor   over Jackson and GSON

of JSON support for speed & efﬁciency • parser forked of the Boon JSON project • serializer carefully ﬁne-tuned ! • Article on the parsing speed improvements • http://rick-hightower.blogspot.fr/2014/04/groovy-and-boon-provide-fastest-json.html

@glaforge #dvxgroovy New modes for parsing • Original JsonSlurper renamed
to JsonSlurperClassic • Additional parsing modes: • INDEX_OVERLAY: super fast for <2MB payloads • using a « parsing overlay » technique • CHARACTER_SOURCE: for >2MB payloads • implemented with sliding windows over readers • LAX: beyond the JSON spec, nice for conﬁguration ﬁles • support single quotes, / and # comments • CHAR_BUFFER: general purpose

@glaforge #dvxgroovy JsonSlurper for configuration files import groovy.json.* import
static groovy.json.JsonParserType.* ! def parser = new JsonSlurper().setType(LAX) ! def conf = parser.parseText ''' // configuration file { // no quote for key, single quoted value environment: 'production' # pound-‐style comment 'server': 5 } ''' ! assert conf.environment == 'production' assert conf.server == 5

static groovy.json.JsonParserType.* ! def parser = new JsonSlurper().setType(LAX) ! def conf = parser.parseText ''' // configuration file { // no quote for key, single quoted value environment: 'production' # pound-‐style comment 'server': 5 } ''' ! assert conf.environment == 'production' assert conf.server == 5 More tolerant parser:   single quotes,   non-quoted keys,   // and # comments, missing comas

static groovy.json.JsonParserType.* ! def parser = new JsonSlurper().setType(LAX) ! def conf = parser.parseText ''' // configuration file { // no quote for key, single quoted value environment: 'production' # pound-‐style comment 'server': 5 } ''' ! assert conf.environment == 'production' assert conf.server == 5

@YourTwitterHandle @glaforge #dvxgroovy M arkup tem plate engine

@glaforge #dvxgroovy Markup template engine • Based on the principles
of Groovy’s « builders » • and particularly the MarkupBuilder class  for generating arbitrary XML / HTML payloads • Compiled statically for fast template rendering • Internationalization aware • provide the desired Locale in the conﬁguration object • usual sufﬁx notation template_fr_FR.tpl • Custom base template class • ability to provide reusable methods across your templates

@glaforge #dvxgroovy Markup template engine — the idea cars {
cars.each { car(make: it.make, name: it.name) } }

cars.each { car(make: it.make, name: it.name) } } Your template

cars.each { car(make: it.make, name: it.name) } } model = [cars: [! new Car(make: 'Peugeot', name: '508'), ! new Car(make: 'Toyota', name: 'Prius’)! ]]

cars.each { car(make: it.make, name: it.name) } } model = [cars: [! new Car(make: 'Peugeot', name: '508'), ! new Car(make: 'Toyota', name: 'Prius’)! ]] Feed a model into your template

cars.each { car(make: it.make, name: it.name) } } model = [cars: [! new Car(make: 'Peugeot', name: '508'), ! new Car(make: 'Toyota', name: 'Prius’)! ]] <cars>! <car make='Peugeot' name='508'/>! <car make='Toyota' name='Prius'/>! </cars>

cars.each { car(make: it.make, name: it.name) } } model = [cars: [! new Car(make: 'Peugeot', name: '508'), ! new Car(make: 'Toyota', name: 'Prius’)! ]] <cars>! <car make='Peugeot' name='508'/>! <car make='Toyota' name='Prius'/>! </cars> Generate the XML output

cars.each { car(make: it.make, name: it.name) } } model = [cars: [! new Car(make: 'Peugeot', name: '508'), ! new Car(make: 'Toyota', name: 'Prius’)! ]] <cars>! <car make='Peugeot' name='508'/>! <car make='Toyota' name='Prius'/>! </cars>

@glaforge #dvxgroovy Markup template engine — in action import groovy.text.markup.*
! def config = new TemplateConfiguration() def engine = new MarkupTemplateEngine(config) def tmpl = engine.createTemplate(''' p("Hello ${model.name}") ''') def model = [name: 'World'] System.out << tmpl.make(model)

@glaforge #dvxgroovy Markup template engine — includes // include another
template include template: 'foo.tpl' // include raw content include unescaped: 'raw.txt' ! // escape & include include escaped: 'to_escape.txt'

@glaforge #dvxgroovy Markup template engine — useful methods // escaped
automatically yield 'some raw content' ! // include raw content yieldUnescaped 'content' ! // <?xml version='1.0'?> xmlDeclaration()

@glaforge #dvxgroovy Markup template engine — useful methods // escaped
automatically yield 'some raw content' ! // include raw content yieldUnescaped 'content' ! // <?xml version='1.0'?> xmlDeclaration() // <!-‐-‐comment-‐-‐> comment 'comment' ! // adds new lines newLine() ! // processing instructions pi(/* ... */)

@glaforge #dvxgroovy Markup template engine — configuration • Conﬁguration options
! • declaration encoding ! • expand empty elements ! • use double quotes ! • newline string ! ! ! ! • auto escape ! • auto indent ! • base template class ! • locale

@glaforge #dvxgroovy Markup template engine — static! • Type-checked templates
available • use createTypeCheckedModelTemplate()   instead of createTemplate() • Advantages • get compilation errors • if a variable is not available • if you make mistakes in the code snippets • even faster templates

@glaforge #dvxgroovy Markup template engine — static! • With typed
check model creation method ! ! ! ! ! • Alternative:   declare your model types in the template

check model creation method ! ! ! ! ! • Alternative:   declare your model types in the template def modelTypes = [cars: "List<Car>"] ! def tmpl = engine. createTypeCheckedModelTemplate(  "page.tpl", modelTypes)

check model creation method ! ! ! ! ! • Alternative:   declare your model types in the template def modelTypes = [cars: "List<Car>"] ! def tmpl = engine. createTypeCheckedModelTemplate(  "page.tpl", modelTypes) modelTypes = { List<Car> cars } ! cars.each { car -‐> p("Car name: $car.name") }

check model creation method ! ! ! ! ! • Alternative:   declare your model types in the template def modelTypes = [cars: "List<Car>"] ! def tmpl = engine. createTypeCheckedModelTemplate(  "page.tpl", modelTypes) modelTypes = { List<Car> cars } ! cars.each { car -‐> p("Car name: $car.name") } Works with createTemplate() too

check model creation method ! ! ! ! ! • Alternative:   declare your model types in the template def modelTypes = [cars: "List<Car>"] ! def tmpl = engine. createTypeCheckedModelTemplate(  "page.tpl", modelTypes) modelTypes = { List<Car> cars } ! cars.each { car -‐> p("Car name: $car.name") }

@YourTwitterHandle @glaforge #dvxgroovy D ocum entation overhaul

@glaforge #dvxgroovy GroovyDoc: new style

@glaforge #dvxgroovy Groovy GDK documentation: new style

@glaforge #dvxgroovy Brand new documentation with Asciidoctor

@glaforge #dvxgroovy Future groovy-lang.org website

@YourTwitterHandle #DVXFR14{session hashtag} @glaforge #dvxgroovy G roovy 3.0

@YourTwitterHandle @glaforge #dvxgroovy M O P 2

@glaforge #dvxgroovy Goals for the new Meta-Object Protocol • Fully
leverage and build upon JDK 7+ invoke dynamic • get Java-like performance even for dynamic code • Rationalize the sedimentation of meta-programming • more coherence, less corner cases & inconsistencies • Provide a notion of « realm » • shield users of « monkey patching » • ﬁner-grained control of meta-programming reach • Private visibility anyone?

@YourTwitterHandle @glaforge #dvxgroovy A ntlr v4 G ram m ar

@glaforge #dvxgroovy Antlr v4 grammar • Problems • Groovy still
uses Antlr v2! • but version 3 and 4 are out • Groovy’s grammar evolved from a Java grammar • harder to ﬁx and evolve, especially with Antlr v2 ! • Advantages • Start from a clean slate • Antlr 4 more tolerant   and powerful regarding ambiguities • Time to clean some   grammar & syntax warts! • Need to implement the   Java 8 constructs!

@glaforge #dvxgroovy Antlr v4 grammar • Problems • Groovy still
uses Antlr v2! • but version 3 and 4 are out • Groovy’s grammar evolved from a Java grammar • harder to ﬁx and evolve, especially with Antlr v2 ! • Advantages • Start from a clean slate • Antlr 4 more tolerant   and powerful regarding ambiguities • Time to clean some   grammar & syntax warts! • Need to implement the   Java 8 constructs! A « Groovy Summer of Code » student to help

@YourTwitterHandle @glaforge #dvxgroovy Java 8 support

@glaforge #dvxgroovy Java 8 support • Additional grammar and semantic
features to support • to keep saying Groovy / Java interoperability is awesome! • New in Java 8 • lambdas • method references • default methods in interfaces • stream API, date / time API • annotations on types & repeated annotations

@glaforge #dvxgroovy Java 8 support • Additional grammar and semantic
features to support • to keep saying Groovy / Java interoperability is awesome! • New in Java 8 • lambdas • method references • default methods in interfaces • stream API, date / time API • annotations on types & repeated annotations Groovy had already: closures, method pointers, mixins, enriched collection & time APIs

@YourTwitterHandle #DVXFR14{session hashtag} @glaforge #dvxgroovy Sum m ary

Groovy rocks the JVM   since 2003!

@YourTwitterHandle #DVXFR14{session hashtag} @glaforge #dvxgroovy Q & A

@glaforge #dvxgroovy Crédit image / Creative Commons • Rue pavée
— By-Nc-Sa • http://www.flickr.com/photos/22914687@N05/4957591422/sizes/l/ • Sous la Tour Eiffel — By-Nc-Sa • http://www.flickr.com/photos/stewiedewie/244850735/sizes/l/in/photostream/ • Sous le pont — By-Nc-Nd • http://www.landscape-photo.net/displayimage.php?pid=5194 • Paris Metro - By-Nc-Sa • http://www.flickr.com/photos/22914687@N05/6317047263/sizes/l/ ! • Slide template created by @glaforge, completed by @nmartignole for Devoxx FR2014

Groovy in 2014 and beyond at Devoxx France

Groovy in 2014 and beyond at Devoxx France

Transcript