Share
Embed
Groovy in 2014 and beyond at GR8Conf US 2014
Latest development of the Groovy programming language
Guillaume Laforge
July 29, 2014
Transcript
69 slides
-
Groovy in 2014 & beyond Guillaume Laforge Groovy Project Manager
http://glaforge.appspot.com @glaforge -
The Groovy roadmap… 2015 2014 2013 Groovy 2.3 Groovy 2.4
Groovy 2.2 Groovy 2.5 ? Groovy 3.0 ? -
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 -
Groovy 2.4 ! • Android support ! • New website
! • Macro system? • New grammar? -
Groovy 3.0 ! • New Meta-Object Protocol ! • Invoke-dynamic
based runtime ! • Rewritten language grammar with Antlr v4 • unless re-scheduled for Groovy 2.4 if GSoC successful -
JDK 8 support — closures & lambdas IntStream.range(1, 100).forEach(s -‐>
System.out.println(s)); ! Files.lines(Paths.get('README.adoc')) .map(it -‐> it.toUpperCase()) .forEach(it -‐> System.out.println(it)); IntStream.range(1, 100).forEach { println it } ! Files.lines(Paths.get('README.adoc')) .map { it.toUpperCase() } .forEach { println it } Use Groovy closures wherever you pass lambdas in Java 8 -
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 -
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 « trait », a new keyword for a new concept a class « implements » a trait the fly() method from the trait is available -
trait Named { String name
} ! class Bird implements Named {} def b = new Bird(name: 'Colibri') ! assert b.name == 'Colibri' Traits: stateful a Groovy property implement the trait Groovy named argument constructor access the property -
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 extend the Named trait access the name property implement the composite trait -
trait FlyingAbility { String 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 (+dyn.) access a dynamic property implements two traits! dynamic ‘name’ property interpolated -
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? two surf() methods extending a class and implementing the two traits last declared trait wins! -
trait KiteSurfer { String surf() { 'kite' } }
! 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 KiteSurfer { String surf() { 'kite' } }
! 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’ Your class method takes precedence over the traits -
trait Named { String 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 -
trait Named { String 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 -
trait Named { String name } ! 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 -
Traits: miscellaneous • Traits can… ! • have private fields
and methods • have abstract methods • implement interfaces • extend other traits or implement several traits • be statically type checked and compiled -
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 Rewrites tail recursive friendly function serially Doesn’t blow up with a stack overflow error Downside of tail recursion is you might have to rewrite your algo to be tailrec friendly -
New: @Sortable import groovy.transform.* ! @Sortable class Person
{ String lastName String firstName int age } Makes the class Comparable by multiple Comparators First compare by lastName, then by firstName, etc. You can also specify ‘includes’ / ‘excludes’ properties -
@BaseScript improvements abstract class CustomBase extends Script {
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 Define the base script class for this script Ability to put the annotation on imports & package -
@BaseScript custom abstract method abstract class CustomBase extends 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 -
JDK 7+ NIO2 module • All the familiar methods on
File retrofitted 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 -
JSON parser / builder perf. increase • Re-implementation of JSON
support for speed & efficiency • parser forked off the Boon JSON project • serializer carefully fine-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 -
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 configuration files • support single quotes, / and # comments • CHAR_BUFFER: general purpose -
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 More tolerant parser: single quotes, non-quoted keys, // and # comments, missing comas -
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 configuration object •usual suffix notation template_fr_FR.tpl • Custom base template class •ability to provide reusable methods across your templates -
Markup template engine — the idea 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> Your template Feed a model into your template Generate the XML output -
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) -
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' -
Markup template engine // escaped automatically yield 'some raw
content' ! // include raw content yieldUnescaped 'content' ! // <?xml version='1.0'?> xmlDeclaration() // <!-‐-‐comment-‐-‐> comment 'comment' ! // adds new lines newLine() ! // process. instruct. pi(/* ... */) -
Markup template engine ! • Configuration options ! • declaration
encoding ! • expand empty elements ! • use double quotes ! • newline string ! ! ! ! ! ! ! • auto escape ! • auto indent ! • base template class ! • locale -
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 -
Markup template engine — static! • With typed check model
creation method ! ! ! ! • Or 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 -
Android support • You can use Groovy to code
Android apps! • use Groovy 2.4.0-beta-1 • prefer @CompileStatic ! • Two great posts to get started: • http://melix.github.io/blog/2014/06/ grooid.html • http://melix.github.io/blog/2014/06/ grooid2.html -
Groovy Macros ! • Sergei Egorov wants to contribute a
macro module • https://github.com/groovy/groovy-core/pull/470 ! • Simplify creation of AST transformations • less boilerplate manipulating the Groovy AST API • more powerful and less limited than AstBuilder -
Groovy Macros ! • Authoring AST transformations can be verbose:
def someVariable = new ConstantExpression("xyz") def returnStatement = new ReturnStatement( new ConstructorCallExpression( ClassHelper.make(SomeCoolClass), new ArgumentListExpression(someVariable) ) ) -
Groovy Macros • With Groovy Macros, it could be simpler:
def someVariable = macro { "xyz" } def returnStatement = macro { new SomeCoolClass($v{ someVariable }) } Special « macro » command Quasi-quotation -
Goals for the new MOP • Leverage & 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 » • finer-grained control of meta-programming reach • Private visibility anyone? -
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 fix 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 « Google Summer of Code » student is currently helping -
Java 8 support • Additional grammar & 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 -
Image credits • 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/ • Big rock • http://wallpaper.preview-reviews.com/12852-red-rocks-in-a-snowstorm • Android robot • http://crackberry.com/sites/crackberry.com/files/styles/large/public/topic_images/2013/ANDROID.png? itok=xhm7jaxS • Modern MOP • http://i933.photobucket.com/albums/ad179/autobin/Wonder%20Mop/wondermop4.jpg • Jason • http://static.comicvine.com/uploads/original/3/32405/1031312-jason_19_inch_figure_l.jpg • Jigsaw • http://www.psdgraphics.com/file/psd-jigsaw-icon.jpg