Upgrade to Pro — share decks privately, control downloads, hide ads and more …

Groovy in 2014 and beyond -- JavaOne 2014

Sponsored · Your Podcast. Everywhere. Effortlessly. Share. Educate. Inspire. Entertain. You do you. We'll handle the rest. →

Groovy in 2014 and beyond -- JavaOne 2014

The latest developments in the Groovy programming language proejct

Guillaume Laforge

October 02, 2014

Transcript

138 slides
  1. The Groovy roadmap 3 2015 2014 2013 Groovy 2.3 Groovy

    2.4 Groovy 2.2 Groovy 2.5 ? Groovy 3.0 ?
  2. JDK 8 support — closures vs lambdas 6 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));
  3. JDK 8 support — closures vs lambdas 6 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  }
  4. JDK 8 support — closures vs lambdas 6 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
  5. 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 and static compilation • class methods from traits also visible from Java classes • Also possible to implement traits at runtime 8
  6. Traits: a simple example 9 trait  FlyingAbility  {    

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

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

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

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

         String  fly()  {  "I'm  flying!"  }   }   ! class  Bird  implements  FlyingAbility  {}   def  b  =  new  Bird()   ! assert  b.fly()  ==  "I'm  flying!"
  11. Traits: stateful 10 trait  Named  {        

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

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

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

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

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

     String  name   }   ! class  Bird  implements  Named  {}   def  b  =  new  Bird(name:  'Colibri')   ! assert  b.name  ==  'Colibri'
  17. Traits: inheritance 11 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!"
  18. Traits: inheritance 11 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!" extend the Named trait
  19. Traits: inheritance 11 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!" access the name property
  20. Traits: inheritance 11 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!" implement the composite trait
  21. Traits: inheritance 11 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!"
  22. Traits: what about conflicts? 12 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'
  23. Traits: what about conflicts? 12 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' two surf() methods
  24. Traits: what about conflicts? 12 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'
  25. Traits: what about conflicts? 12 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' extending a class and implementing the two traits
  26. Traits: what about conflicts? 12 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'
  27. Traits: what about conflicts? 12 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' last declared trait wins!
  28. Traits: what about conflicts? 12 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'
  29. Traits: what about conflicts? 13 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'
  30. Traits: what about conflicts? 13 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' reverse the order!
  31. Traits: what about conflicts? 13 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'
  32. Traits: what about conflicts? 14 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'
  33. Traits: what about conflicts? 14 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' Be explicit! Override surf() 
 & use ‘super’
  34. Traits: what about conflicts? 14 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' Your class method takes precedence over the traits
  35. Traits: what about conflicts? 14 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'
  36. trait  Named  {          String  name  

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

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

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

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

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

    }   ! class  Animal  {}   ! ! def  na  =  new  Animal()  as  Named   na.name  =  'Felix'   assert  na.name  ==  'Felix' Traits: runtime implementation 16
  42. Traits: runtime implementation 17 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!'
  43. Traits: runtime implementation 17 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!' Implement several traits at once, at runtime
  44. Traits: runtime implementation 17 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!'
  45. New: @TailRecursive 19 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
  46. New: @TailRecursive 19 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
  47. New: @TailRecursive 19 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 Doesn’t blow up with a stack overflow error
  48. New: @TailRecursive 19 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 Downside of tail recursion is 
 you might have to rewrite 
 your algo to be tailrec friendly
  49. New: @TailRecursive 19 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
  50. New: @Sortable 20 import  groovy.transform.*   ! @Sortable   class

     Person  {          String  lastName          String  firstName          int  age   }
  51. New: @Sortable 20 import  groovy.transform.*   ! @Sortable   class

     Person  {          String  lastName          String  firstName          int  age   } Makes the class Comparable by multiple Comparators
  52. New: @Sortable 20 import  groovy.transform.*   ! @Sortable   class

     Person  {          String  lastName          String  firstName          int  age   } First compare by lastName, then by firstName, etc.
  53. New: @Sortable 20 import  groovy.transform.*   ! @Sortable   class

     Person  {          String  lastName          String  firstName          int  age   } You can also specify ‘includes’ / ‘excludes’ properties
  54. New: @Sortable 20 import  groovy.transform.*   ! @Sortable   class

     Person  {          String  lastName          String  firstName          int  age   }
  55. @BaseScript improvements 21 abstract  class  CustomBase  extends  Script  {  

           int  meaningOfLife  =  42   } @BaseScript(CustomBase)   import  groovy.transform.BaseScript   ! assert  meaningOfLife  ==  42
  56. @BaseScript improvements 21 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
  57. @BaseScript improvements 21 abstract  class  CustomBase  extends  Script  {  

           int  meaningOfLife  =  42   } @BaseScript(CustomBase)   import  groovy.transform.BaseScript   ! assert  meaningOfLife  ==  42 Define the base script class for this script
  58. @BaseScript improvements 21 abstract  class  CustomBase  extends  Script  {  

           int  meaningOfLife  =  42   } @BaseScript(CustomBase)   import  groovy.transform.BaseScript   ! assert  meaningOfLife  ==  42 Ability to put the annotation on imports & package
  59. @BaseScript improvements 21 abstract  class  CustomBase  extends  Script  {  

           int  meaningOfLife  =  42   } @BaseScript(CustomBase)   import  groovy.transform.BaseScript   ! assert  meaningOfLife  ==  42
  60. @BaseScript custom abstract method 22 abstract  class  CustomBase  extends  Script

     {      def  run()  {          before()          internalRun()          after()      }   !    abstract  internalRun()   !    def  before()  {  println  'before'  }      def  after()    {  println  'after'    }   }
  61. @BaseScript custom abstract method 22 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'
  62. @BaseScript custom abstract method 22 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
  63. @BaseScript custom abstract method 22 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'
  64. JDK 7+ NIO2 module • All the familiar methods on

    File 
 retrofitted on Path as well 24 path.withReader  {  Reader  r  -­‐>  ...  }   path.eachLine  {  String  line  -­‐>  ...  }   path.eachFileRecurse  {  Path  p  -­‐>  ...  }   path  <<  'some  content'   path  <<  bytes   path.readLines()   …
  65. JDK 7+ NIO2 module • All the familiar methods on

    File 
 retrofitted on Path as well 24 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
  66. JDK 7+ NIO2 module • All the familiar methods on

    File 
 retrofitted on Path as well 24 path.withReader  {  Reader  r  -­‐>  ...  }   path.eachLine  {  String  line  -­‐>  ...  }   path.eachFileRecurse  {  Path  p  -­‐>  ...  }   path  <<  'some  content'   path  <<  bytes   path.readLines()   …
  67. 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 26
  68. 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 26
  69. 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 26 Benchmark gives 3x to 4x performance factor 
 over Jackson and GSON
  70. 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 26
  71. New modes for parsing • Original JsonSlurper renamed to JsonSlurperClassic

    ! • Additional parsing modes: • INDEX_OVERLAY: super fast for <2MB payloads o using a « parsing overlay » technique • CHARACTER_SOURCE: for >2MB payloads o implemented with sliding windows over readers • LAX: beyond the JSON spec, nice for configuration files o support single quotes, / and # comments • CHAR_BUFFER: general purpose 27
  72. JsonSlurper for configuration files 28 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
  73. JsonSlurper for configuration files 28 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
  74. JsonSlurper for configuration files 28 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
  75. 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 30
  76. 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 30 Spring Boot approved
  77. Markup template engine — the idea 31 cars  {  

         cars.each  {                car(make:  it.make,  name:  it.name)        }   }
  78. Markup template engine — the idea 31 cars  {  

         cars.each  {                car(make:  it.make,  name:  it.name)        }   } Your template
  79. Markup template engine — the idea 31 cars  {  

         cars.each  {                car(make:  it.make,  name:  it.name)        }   } model = [cars: [! new Car(make: 'Peugeot', name: '508'), ! new Car(make: 'Toyota', name: 'Prius’)! ]]
  80. Markup template engine — the idea 31 cars  {  

         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
  81. Markup template engine — the idea 31 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>
  82. Markup template engine — the idea 31 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
  83. Markup template engine — the idea 31 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>
  84. Markup template engine — in action 32 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)
  85. Markup template engine — includes 33 //  include  another  template

      include  template:  'foo.tpl'           //  include  raw  content   include  unescaped:  'raw.txt'   ! //  escape  &  include   include  escaped:  'to_escape.txt'
  86. Markup template engine — static! • Type-checked templates available •

    use createTypeCheckedModelTemplate() 
 instead of createTemplate() ! • Advantages • get compilation errors o if a variable is not available o if you make mistakes in the code snippets • even faster templates 34
  87. Markup template engine — static! • With typed check model

    creation method ! ! ! ! ! ! ! ! ! • Or declare your model types in the template 35
  88. Markup template engine — static! • With typed check model

    creation method ! ! ! ! ! ! ! ! ! • Or declare your model types in the template 35 def  modelTypes  =  [cars:  "List<Car>"]   ! def  tmpl  =  engine.      createTypeCheckedModelTemplate(
            "page.tpl",  modelTypes)
  89. Markup template engine — static! • With typed check model

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

    creation method ! ! ! ! ! ! ! ! ! • Or declare your model types in the template 35 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
  91. Markup template engine — static! • With typed check model

    creation method ! ! ! ! ! ! ! ! ! • Or declare your model types in the template 35 def  modelTypes  =  [cars:  "List<Car>"]   ! def  tmpl  =  engine.      createTypeCheckedModelTemplate(
            "page.tpl",  modelTypes) modelTypes  =  {          List<Car>  cars   }   ! cars.each  {  car  -­‐>          p("Car  name:  $car.name")   }
  92. 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 42
  93. New York Times — Getting Groovy with Android • New

    York Times Getting Groovy with Reactive Android 43
  94. New York Times — Getting Groovy with Android • New

    York Times Getting Groovy with Reactive Android 43 http://bit.ly/nyt-groovy
  95. 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 45
  96. Groovy Macros ! • Authoring AST transformations can be verbose:

    46 def  someVariable  =  new  ConstantExpression("xyz")   def  returnStatement  =  new  ReturnStatement(          new  ConstructorCallExpression(                  ClassHelper.make(SomeCoolClass),                  new  ArgumentListExpression(someVariable)          )   )
  97. Groovy Macros • With Groovy Macros, it could be simpler:

    47 def  someVariable  =  macro  {  "xyz"  }   def  returnStatement  =  macro  {            new  SomeCoolClass($v{  someVariable  })     }
  98. Groovy Macros • With Groovy Macros, it could be simpler:

    47 def  someVariable  =  macro  {  "xyz"  }   def  returnStatement  =  macro  {            new  SomeCoolClass($v{  someVariable  })     } Special « macro » command
  99. Groovy Macros • With Groovy Macros, it could be simpler:

    47 def  someVariable  =  macro  {  "xyz"  }   def  returnStatement  =  macro  {            new  SomeCoolClass($v{  someVariable  })     } Special « macro » command Quasi-quotation
  100. 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? 51
  101. @glaforge — Groovy in 2014 and beyond Rewriting the Groovy

    grammar with Antlr v4 Antlr v4 Grammar
  102. Antlr v4 grammar • Problems • Groovy still uses Antlr

    v2! o but version 3 and 4 are out • Groovy’s grammar evolved from a Java grammar o 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! 53
  103. Antlr v4 grammar • Problems • Groovy still uses Antlr

    v2! o but version 3 and 4 are out • Groovy’s grammar evolved from a Java grammar o 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! 53 A « Google Summer of Code » student helped kick start it
  104. @glaforge — Groovy in 2014 and beyond Support the new

    Java 8 language features Java 8 language support
  105. 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 55
  106. 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 55 Groovy had already: closures, method pointers, mixins, enriched collection & time APIs
  107. Image credits • 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 • Many thanks • http://www.trys.ie/wp-content/uploads/2013/06/many-thanks.jpg 60

More Decks by Guillaume Laforge

Other Decks in Programming