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

More Decks by Guillaume Laforge

Other Decks in Technology

Featured

Transcript