World Library  
Flag as Inappropriate
Email this Article

Groovy (programming language)

Article Id: WHEBN0000508401
Reproduction Date:

Title: Groovy (programming language)  
Author: World Heritage Encyclopedia
Language: English
Subject: SCaViS, Gradle, Generational list of programming languages, Java/Selected article, Scala (programming language)
Collection:
Publisher: World Heritage Encyclopedia
Publication
Date:
 

Groovy (programming language)

Groovy
Groovy-logo
Paradigm(s) Object-oriented, imperative, scripting, functional
Designed by James Strachan
Developer Guillaume LaForge
(Project Manager)
Jochen Theodorou (Tech Lead)
Paul King
Cedric Champeau
Appeared in 2003
Stable release 2.3.7 / September 25, 2014 (2014-09-25)[1]
Typing discipline Dynamic, Static, Strong, Duck
Influenced by Java, Python, Ruby, Perl, Smalltalk, Objective-C
Influenced Kotlin
Platform Java Virtual Machine
OS Cross-platform
License Apache License v2.0
Website .org.codehausgroovy

Groovy is an object-oriented programming language for the Java platform. It is a dynamic language with features similar to those of Python, Ruby, Perl, and Smalltalk. It can be used as a scripting language for the Java Platform, is dynamically compiled to Java Virtual Machine (JVM) bytecode, and interoperates with other Java code and libraries. Groovy uses a Java-like curly-bracket syntax. Most Java code is also syntactically valid Groovy.

Groovy 1.0 was released on January 2, 2007, and Groovy 2.0 in July, 2012. Groovy 3.0 is planned for release in late 2014, with support for a new Meta Object Protocol.[2] Since version 2, Groovy can also be compiled statically, offering type inference and performance very close to that of Java.[3][4] Groovy is backed by Pivotal Software.

History

James Strachan first talked about the development of Groovy on his blog in August 2003.[5] Several versions were released between 2004 and 2006. After the JCP standardization process began, the version numbering changed and a version called "1.0" was released on January 2, 2007. After various betas and release candidates numbered 1.1, on December 7, 2007, Groovy 1.1 Final was released and immediately rebranded as Groovy 1.5 as a reflection of the many changes made.

In 2007, Groovy won the first prize at JAX 2007 innovation award.[6] In 2008, Grails, a Groovy web framework, won the second prize at JAX 2008 innovation award.[7]

In November 2008, SpringSource acquired the Groovy and Grails company (G2One).[8] In August 2009 VMWare acquired SpringSource.[9]

In July 2009, Strachan wrote on his blog, "I can honestly say if someone had shown me the Programming in Scala book by Martin Odersky, Lex Spoon & Bill Venners back in 2003 I'd probably have never created Groovy."[10] Strachan had left the project silently a year before the Groovy 1.0 release in 2007.

In March 2004, Groovy had been submitted to the Java Community Process as JSR 241 [11] and accepted by ballot. After 8 years of inactivity, the Spec Lead changed its status to dormant in April 2012.

On July 2, 2012, Groovy 2.0 was released, which, among other new features, added static compilation and a static type checker to Groovy.

Features

Most valid Java files are also valid Groovy files. Although the two languages are similar, Groovy code can be more compact, because it does not require all the elements that Java requires.[12] This makes it possible for Java programmers to gradually learn Groovy by starting with familiar Java syntax before acquiring more Groovy idioms.[13]

Groovy features not available in Java include both static and dynamic typing (with the def keyword), operator overloading, native syntax for lists and associative arrays (maps), native support for regular expressions, polymorphic iteration, expressions embedded inside strings, additional helper methods, and the safe navigation operator "?." to automatically check for nulls (for example, "variable?.method()", or "variable?.field").[14]

Since version 2 Groovy also supports modularity, being able to ship only the needed jars according to the project needs, thus reducing the size of groovy's lib, type checking, static compilation, Project Coin syntax enhancements, multicatch blocks and ongoing performance enhancements using JDK7's invoke dynamic instruction.[15]

Groovy's syntax can be made far more compact than Java. For example, a declaration in Standard Java 5+ such as:

 for (String it : new String[] {"Rod", "Carlos", "Chris"})
     if (it.length() <= 4)
         System.out.println(it);

can be expressed in Groovy as:

 ["Rod", "Carlos", "Chris"].findAll{it.size() <= 4}.each{println it}

Groovy provides native support for various markup languages such as XML and HTML, accomplished via an inline DOM syntax. This feature enables the definition and manipulation of many types of heterogeneous data assets with a uniform and concise syntax and programming methodology.

Unlike Java, a Groovy source code file can be executed as an (uncompiled) script if it contains code outside any class definition, is a class with a main method, or is a Runnable or GroovyTestCase. A Groovy script is fully parsed, compiled, and generated before execution (similar to Perl and Ruby). (This occurs under the hood, and the compiled version is not saved as an artifact of the process.)[16]

GroovyBeans / Properties

GroovyBeans are Groovy's version of JavaBeans. Groovy implicitly generates accessor and mutator methods. In the following code, setColor(String color) and getColor() are implicitly generated; and the last two lines, which appear to access color directly, are actually calling the implicitly generated methods.[17]

class AGroovyBean {
  String color
}

def myGroovyBean = new AGroovyBean()

myGroovyBean.setColor('baby blue')
assert myGroovyBean.getColor() == 'baby blue'

myGroovyBean.color = 'pewter'
assert myGroovyBean.color == 'pewter'

Groovy offers simple, consistent syntax for handling lists and maps, reminiscent of Java's array syntax.[18]

def movieList = ['Dersu Uzala', 'Ran', 'Seven Samurai']  //looks like an array, but is a list
assert movieList[2] == 'Seven Samurai'
movieList[3] = 'Casablanca'  //adds an element to the list
assert movieList.size() == 4

def monthMap = [ 'January' : 31, 'February' : 28, 'March' : 31 ]  //declares a map
assert monthMap['March'] == 31  //accesses an entry
monthMap['April'] = 30  //adds an entry to the map
assert monthMap.size() == 4

Metaprogramming

Groovy offers support for metaprogramming through ExpandoMetaClass, Extension Modules (only in Groovy 2), Categories and DelegatingMetaClass.[19]

ExpandoMetaClass offers a DSL to express easily the changes in the class, similar to Ruby's open class concept:

Number.metaClass {
  sqrt = { Math.sqrt(delegate) }
}

assert 9.sqrt() == 3
assert 4.sqrt() == 2

Groovy's changes in code through metaprogramming are not visible in Java, since each attribute/method invocation in Groovy goes through the metaclass registry. The changed code can only be accessed from Java by going to the metaclass registry.

Groovy also allows overriding methods as getProperty(), propertyMissing() among others, enabling the developer to intercept calls to an object and specify an action for them, in a simplified aspect oriented way. The following code enables the class java.lang.String to respond to the hex property:

enum Color {
  BLACK('#000000'), WHITE('#FFFFFF'), RED('#FF0000'), BLUE('#0000FF')
  String hex
  Color(String hex) { 
    this.hex = hex 
  }
}

String.metaClass.getProperty = { String property ->
  def stringColor = delegate
  if (property == 'hex') {
    Color.values().find { it.name().equalsIgnoreCase stringColor }?.hex
  }
}

assert "WHITE".hex == "#FFFFFF"
assert "BLUE".hex == "#0000FF"
assert "BLACK".hex == "#000000"
assert "GREEN".hex == null

The Grails framework uses metaprogramming extensively to enable GORM dynamic finders, like User.findByName('Josh') and others.[20]

Dot and parentheses

Groovy's syntax permits omitting parentheses and dots in some situations. The following groovy code (from Guillaume LaForge's DSL slideshare)

take(coffee).with(sugar, milk).and(liquor)

can be written as

take coffee with sugar, milk and liquor

enabling the development of Domain-specific languages (DSLs) which look like plain English.

Functional programming

Although Groovy is mostly an object-oriented language, it also offers functional features.

Closures

According to Groovy's documentation: "Closures in Groovy work similar to a 'method pointer', enabling code to be written and run in a later point in time".[21] Groovy's closures support free variables, i.e. variables which have not been explicitly passed as a parameter to it, but exist in its declaration context, partial application (which it terms 'currying'[22]), delegation, implicit, typed and untyped parameters.

When working on Collections of a determined type, the closure passed to an operation on the collection can be inferred:

list = [1, 2, 3, 4, 5, 6, 7, 8, 9]

/* 
 * The type of the implicit "it" parameter can be inferred as an Integer by the IDE.
 * It could also be written as:
 * list.findAll { Integer i -> i % 2 }
 * list.findAll { i -> i % 2 }
 */
def odds = list.findAll { it % 2 }

assert odds == [1, 3, 5, 7, 9]

A group of expressions can be written in a closure block without reference to an implementation and the responding object can be assigned at a later point using delegation:

// This block of code contains expressions without reference to an implementation
def operations = {
  declare 5
  sum 4
  divide 3
  print
}

/* 
 * This class will handle the operations that can be used in the closure above. We could declare 
 * another class having the same methods, but using, for example, webservice operations in the
 * calculations.
 */
class Expression {
  BigDecimal value

  /* 
   * Though an Integer is passed as a parameter, it is coerced into a BigDecimal, as we defined. 
   * If the class had a 'declare(Integer value)' method, it would be used instead.
   */
  def declare(BigDecimal value) {
    this.value = value
  }
  
  def sum(BigDecimal valueToAdd) {
    this.value += valueToAdd
  }
  
  def divide(BigDecimal divisor) {
    this.value /= divisor
  }
  
  def propertyMissing(String property) {
    if (property == "print") println value
  }
}

// Here we define who is going to respond the expressions in the block
operations.delegate = new Expression()
operations()

Curry

Usually called partial application,[22] this Groovy feature allows closures parameters to be set to a default parameters in any of its arguments, creating a new closure with the bound value. If you supply one argument to the curry() method you will fix the first argument. If you supply N arguments you will fix arguments 1..N.

def joinTwoWordsWithSymbol = { symbol, first, second -> first + symbol + second }
assert joinTwoWordsWithSymbol('#', 'Hello', 'World') == 'Hello#World'

def concatWords = joinTwoWordsWithSymbol.curry(' ')
assert concatWords('Hello', 'World') == 'Hello World'

def prependHello = concatWords.curry('Hello')
// def prependHello = joinTwoWordsWithSymbol.curry(' ', 'Hello')
assert prependHello('World') == 'Hello World'

Curry can also be used in the reversed direction (fixing arguments N to N-1) using rcurry.

def power = { BigDecimal value, BigDecimal power ->
  value ** power
}

def square = power.rcurry(2)
def cube = power.rcurry(3)

assert power(2, 2) == 4
assert square(4) == 16
assert cube(3) == 27

Groovy also supports lazy evaluation,[23][24] reduce/fold,[25] infinite structures and immutability,[26] among others.[27]

XML and JSON Processing

On XML and JSON processing Groovy employs the Builder pattern, making the production of the data structure less verbose. For example, the following XML:


  
    java
    Object oriented
    Static
  
  
    ruby
    Object oriented, Functional
    Dynamic, duck typing
    
  
    groovy
    Object oriented, Functional
    Dynamic, Static, Duck typing
  

Can be generated through the following Groovy code:

def writer = new StringWriter()
def builder = new groovy.xml.MarkupBuilder(writer)
builder.languages {
  language(year: 1995) {
    name "java"
    paradigm "object oriented"
    typing "static"
  }
  language (year: 1995) {
    name "ruby"
    paradigm "object oriented, functional"
    typing "dynamic, duck typing"
  }
  language (year: 2003) {
    name "groovy"
    paradigm "object oriented, functional"
    typing "dynamic, static, duck typing"
  }
}

And also can be processed in a streaming way through StreamingMarkupBuilder. To change the implementation to JSON, we can just swap the MarkupBuilder to JsonBuilder.[28]

To parse it and search for a functional language we can use Groovy's findAll method:

def languages = new XmlSlurper().parseText writer.toString()

// Here we employ groovy's regex syntax for a matcher (=~) which will be coerced to a boolean value: 
// either true if the value contains our string, or false otherwise.
def functional = languages.language.findAll { it.paradigm =~ "functional" }
assert functional.collect { it.name } == ["ruby", "groovy"]

String interpolation

In Java, when creating a string by joining a string literal to an expression, it's necessary to end the literal and use the concatenation operator (+). In Groovy we can interpolate the string with variables and expressions by using GStrings:[29]

BigDecimal account = 10.0
def text = "Your account shows currently a balance of $account"
assert text == "Your account shows currently a balance of 10.0"

GStrings containing variables and expressions must be declared using double quotes.

A complex expression must be enclosed in curly brackets. This prevents parts of it from being interpreted as belonging to the surrounding string instead of to the expression:

BigDecimal minus = 4.0
text = "Your account shows currently a balance of ${account - minus}"
assert text == "Your account shows currently a balance of 6.0"

// Without the brackets to isolate the expression, we would have the following:
text = "Your account shows currently a balance of $account - minus"
assert text == "Your account shows currently a balance of 10.0 - minus"

Expression evaluation can be deferred by employing arrow syntax:

BigDecimal tax = 0.15
text = "Your account shows currently a balance of ${->account - account * tax}"
tax = 0.10

// The tax value was changed AFTER declaration of the GString. The expression 
// variables are bound only when the expression must actually be evaluated:

assert text == "Your account shows currently a balance of 9.000"

AST (Abstract Syntax Tree) Transformation

According to Groovy's own documentation, "When the Groovy compiler compiles Groovy scripts and classes, at some point in the process, the source code will end up being represented in memory in the form of a Concrete Syntax Tree, then transformed into an Abstract Syntax Tree. The purpose of AST Transformations is to let developers hook into the compilation process to be able to modify the AST before it is turned into bytecode that will be run by the JVM. AST Transformations provides Groovy with improved compile-time metaprogramming capabilities allowing powerful flexibility at the language level, without a runtime performance penalty.".[30]

Examples of ASTs in Groovy are:

  • Singleton transformation;
  • Category and Mixin transformation;
  • Immutable AST Macro;
  • Newify transformation;

Among others.

Traits

According to Groovy's documentation, "Traits are a structural construct of the language which allow: composition of behaviors, runtime implementation of interfaces, behavior overriding, and compatibility with static type checking/compilation"

Traits can be seen as interfaces carrying both default implementations and state. A trait is defined using the trait keyword:

trait FlyingAbility { /* declaration of a trait */
    String fly() { "I'm flying!" } /* declaration of a method inside a trait */
}

Then it can be used like a normal interface using the implements keyword:

class Bird implements FlyingAbility {} /* Adds the trait FlyingAbility to the Bird class capabilities */
def b = new Bird() /* instantiate a new Bird */
assert b.fly() == "I'm flying!" /* the Bird class automatically gets the behavior of the FlyingAbility trait */

Traits allow a wide range of capabilities, from simple composition to testing.

Learn More at Groovy's Trait Documentation Page

Adoption

  • Groovy is used in massive financial applications on top of a DSL and distributed environment.[31][32]
  • Wired.com uses Groovy and Grails.
  • Though Groovy can be integrated into any JVM environment, the JBoss Seam framework provides Groovy, besides Java, as a development language, out of the box.
  • The European Patent Office (EPO) developed a Data Flow Language in Groovy "to leverage similarities in the processes for communicating with each individual country’s patent office, and transform them into a single, universal process."
  • Linkedin uses Groovy and Grails for some of their subsystems.
  • XWiki SAS uses Groovy as scripting language in their collaborative open-source product.
  • SoapUI provides Groovy as a language for webservice tests development.
  • Sky.com uses Groovy and Grails to serve massive online media content.
  • vCalc.com uses Groovy for all of the user defined mathematics in its math crowd-sourcing engine [1].
  • Eucalyptus, a cloud management system, uses a significant amount of Groovy.

IDE support

Many integrated development environments and text editors support Groovy:

See also

References

Notes

  1. ^ "groovy". 25 September 2014. 
  2. ^ "Roadmap". 
  3. ^ "Groovy 2.0 Performance compared to Java". 25 Aug 2012. 
  4. ^ "Java vs Groovy2.0 vs Scala Simple Performance Test". 10 Jul 2012. 
  5. ^ James Strachan (29 Aug 2003). "Groovy - the birth of a new dynamic language for the Java platform". 
  6. ^ "Groovy wins first prize at JAX 2007 innovation award". 2007-04-26. 
  7. ^ "They say a lot can happen over a cup of coffee". 
  8. ^ "SpringSource Acquires Groovy and Grails company (G2One)". 11 Nov 2008. 
  9. ^ "VMWare Acquires SpringSource". 10 Aug 2009. 
  10. ^ "Scala as the long term replacement for java/javac?". July 6, 2009. Retrieved 2009-12-29. 
  11. ^ "Java Community Process JSR 241". 
  12. ^ König 2007, pg. 32
  13. ^ Q & A with Ed Povazan on Groovy, Dynamic Languages for Java, the State-of-the Eclipse Groovy Plugin and More (Part I)
  14. ^ "Groovy - Differences from Java". Groovy.codehaus.org. Retrieved 2013-08-12. 
  15. ^ "What's new in Groovy 2.0?". 28 Jun 2012. 
  16. ^ König 2007, pp. 37-8
  17. ^ König 2007, pp. 38-9
  18. ^ König 2007, pp. 41-3
  19. ^ "JN3525-MetaClasses". 
  20. ^ "Metaprogramming Techniques in Groovy and Grails". 11 Jun 2009. 
  21. ^ "Groovy - Closures". 
  22. ^ a b "Does groovy call partial application 'currying'". 10 Aug 2013
  23. ^ "Groovy - Lazy Transformation". 
  24. ^ "Side Notes: Lazy lists in Groovy". 3 Feb 2011. 
  25. ^ "Groovy's Fold". 20 Jun 2011. 
  26. ^ "Functional Programming with Groovy". 5 Nov 2011. 
  27. ^ "Function programming in Groovy". 
  28. ^ "JsonBuilder". 
  29. ^ "Groovy Strings - Different ways of creating them". 26 Dev. 2009. 
  30. ^ "Compile-time Metaprogramming - AST Transformations". 
  31. ^ "Groovy Finance". 27 May 2009. 
  32. ^ "The Gr8 Conference: Grid computing and computational finance". 20 May 2009. 

External links

  • Official website
  • An introduction to Groovy
  • Groovy at DMOZ
  • Interview with Guillaume LaForge about Groovy, from QCon London 2007
  • Interview with Guillaume LaForge and Graeme Rocher about Groovy and Grails, from SpringOne New Orleans 2009
This article was sourced from Creative Commons Attribution-ShareAlike License; additional terms may apply. World Heritage Encyclopedia content is assembled from numerous content providers, Open Access Publishing, and in compliance with The Fair Access to Science and Technology Research Act (FASTR), Wikimedia Foundation, Inc., Public Library of Science, The Encyclopedia of Life, Open Book Publishers (OBP), PubMed, U.S. National Library of Medicine, National Center for Biotechnology Information, U.S. National Library of Medicine, National Institutes of Health (NIH), U.S. Department of Health & Human Services, and USA.gov, which sources content from all federal, state, local, tribal, and territorial government publication portals (.gov, .mil, .edu). Funding for USA.gov and content contributors is made possible from the U.S. Congress, E-Government Act of 2002.
 
Crowd sourced content that is contributed to World Heritage Encyclopedia is peer reviewed and edited by our editorial staff to ensure quality scholarly research articles.
 
By using this site, you agree to the Terms of Use and Privacy Policy. World Heritage Encyclopedia™ is a registered trademark of the World Public Library Association, a non-profit organization.
 


Copyright © World Library Foundation. All rights reserved. eBooks from Project Gutenberg are sponsored by the World Library Foundation,
a 501c(4) Member's Support Non-Profit Organization, and is NOT affiliated with any governmental agency or department.