1. INTRODUCTION
Apache Groovy is built to work closely and seamlessly with the Java platform, it even shares a majority of syntax with Java to provide an easier learning curve. One of its more notable features includes its ability to do both dynamic and static type binding. In addition, it can be used to write scripts, and Groovy classes can directly work with Java classes (Apache Groovy, 2019). According to an article by IndicThreads Apache Groovy receives over 30,000 downloads every month (2008). The concept of this language began with James Strachan and was developed by a group at G2One.
On August 29th, 2003, James Strachan announced his plan for Groovy, a brand-new language built on the shoulders of the Java platform that preceded it (Strachan, 2003). He had a concept of how to build upon the existing Java platform in a way that had not been done before. In his eyes, a gap existed between the current languages for the Java platform and what was needed. With this in mind, Strachan began development on the language, as he mentions in his blog (Strachan, 1993).
At this point, the history of the language grows hazy. Not much of a digital footprint exists about the early development. What is known, however, is that the first version of Groovy was released in January of 2007, four years after Strachan first mentions the idea for the language (Apache Groovy, 2019). Notable releases afterword include Groovy 1.5, the first update of considerable size after its initial release, and Groovy 2.0 when static typing was added to the language.
Groovy was not known as “Apache Groovy” from its inception, but rather it traded several hands before arriving there. Initially it was created by G2One, a company founded by several of Groovy’s main developers (IndicThreads, 2008). Just one year after Groovy’s first stable release, it was acquired by SpringSource, a company developing tools for Java. Along the way, SpringSource along with its parent company VMware partnered with Pivotal software, until Pivotal stopped funding Groovy in 2015 (Pivotal, 2015). After this long journey, Groovy final settled in as a part of the Apache Software Foundation.
Groovy is used in many modern business and programs. Some notable companies include Netflix, Google, Sony, and MasterCard (Apache Groovy, 2019).
2. PHILOSOPHY
From the outset, Strachan had a general idea of what he wanted to accomplish with the language, which he outlined his blog post announcing the language (2003). He wanted one that seamlessly integrated with the Java environment, and he wanted it to bring a dynamic type binding scripting language to the world of Java. Other languages for the Java virtual machine existed at the time, but he saw these as lacking to adequately accomplish what was needed. He wanted to design something that provided a better experience for the programmer.
In his blog post, Strachan also mentions his desire for a language syntax that allows quick prototyping like that of Python. And while some languages with Python-like syntax did exist for the Java platform, Strachan’s critique was that none of them had the ability to directly interact with classes in Java (2003).
Initially, Strachan’s main goal was for Groovy to be used as a scripting language. If it was eventually able to be used to develop full applications, that was seen as an added benefit (Strachan 2003). By the release of Groovy 1.0, both were available. One of the developers announced in a blog post that Groovy supports both scripting and web applications (Laforge, 2007).
It is unclear whether Strachan kept working on Groovy throughout all of its development, however this philosophy was carried out to completion. Groovy has both scripting capabilities and a Python-like syntax. It also has a low barrier for entry for Java developers, due to its similarity to Java and use of Java libraries and classes.
3. INFLUENCE
As a language built to work as smoothly as possible with the Java platform, Groovy naturally was greatly influenced by Java. They even share a great amount of syntax. One of the original founders discusses his desire for a quick syntax, because others of that time were not as easy to pick up for Java programmers (Strachan 2003). He expressed interest in the design of both Python and Ruby but saw that they had no role in integrating with the Java environment.
As a self-professed “die hard” Java programmer, Strachan searched for a new answer, gaining inspiration from these popular tools to integrate into the language he would design. Groovy’s dynamic type binding shows the developer’s favor for the ability of languages like Python to get something built relatively quickly. Strachan’s idea was to build upon the shoulders of Java, not to redo it. Therefore, Strachan used his influences to build on useful features to what was already existent in Java.
Although it has many similarities with Java, Groovy does want to differentiate itself. Apache Groovy’s website has a specific list of differences between the two languages (Apache Groovy). Many are minor syntactic differences. Groovy adds a few additional keywords, as well as automatically includes a set of Java libraries. Groovy and Java’s == operator behave differently, and arrays must be initialized using a different syntax due to closures.
Though greatly influenced by dynamic languages such as Python and Ruby, Groovy would later add static binding and compilation capabilities (Apache Groovy, 2019). The release notes state that they did this for those developers using Groovy as a new and improved form of Java. This allowed Groovy to perform static type checking, and therefore make the language more reliable.
Groovy laid the pathway for other languages of this type for the Java platform. It has even gone one to influence other well known languages such as C#, Swift, Javascript, Kotlin, and Ruby (Laforge, 2017). One feature that made it to most of these influenced languages is the Elvis operator, a variant of the ternary operator. Other features that were carried on from Groovy includes its concept of closures and the null-safe operator.
4. CRITICISM
Despite Groovy’s well received features, the language was also met with criticism. One of the biggest setbacks for the language was speed. Many were concerned that it simply was not fast enough. Though dynamically typed languages are generally slower than statically typed ones, Groovy still appeared to be slow even among its dynamically typed relatives (Binstock, 2013). To fix this issue, Groovy introduced static typing and compilation, which Binstock says ameliorates the issue. However, he still has more criticisms for the language.
Binstock complains that Groovy lacks extensive documentation. He worked on his own project using Groovy, but found the lack of documentation to be a hinderance. Though its syntax can make it easy for one to quickly get acquainted with the language, it can be more difficult for someone to learn the more nuanced aspects. A thorough documentation would allow programmers to dedicate themselves to the language and learn the ins and outs. Without it, it may be difficult for users to tackle more difficult problems using Groovy.
Binstock’s final criticism is that the language does not have a specific enough direction. He believes there are no sufficiently specific goals for the language. This can cause the language to get side tracked implementing other features, rather than chasing directly after clearly set goals. However, this may also the language to have more of the features that the users desire. Because of this lack of plan, Binstock doubts the future of the language, despite the potential he believes it has (2013).
In his article “Why Groovy is not that famous?”, Michele Nasti addresses some of the pros and cons of the Groovy language (2016). Many people may be arguing why there is a need for Groovy anymore. With recent updates of Java, Groovy programming features may not present a big enough benefit for programmers to use the language. Nasti states that the case in which one would have a use for Groovy, is when one needs a dynamic scripting language for the Java platform.
5. OBJECT ORIENTED PROGRAMMING
Groovy, like Java, is an object oriented language and therefore supports most common object oriented features of a language. As in Java, Groovy uses all things as objects (Apache Groovy, 2019). Groovy classes behave in a similar manner to those in Java, besides a few added features and a few differences in behavior. A useful feature added by Groovy, is for properties of classes. Getters and setters are automatically created for any properties in the class. This can improve the efficiency of writing code for the programmer. Because it is a dynamically typed language, it allows for easy writing of generic classes and methods.
5.1 Encapsulation
Groovy is an object oriented programming language and therefore supports encapsulation. However, data members in a class are not automatically hidden. The programmer must specify that he wants a data member to be private, or otherwise data members will default to public (Apache Groovy, 2019). Although Groovy supports dynamic and static type binding, Groovy recommends to use static type binding in classes to create a more solid contract between the programmer and the user (See Figure 1).
5.2 Inheritance
At the current time of writing, Groovy’s documentation lacks a section on inheritance. However, like Java, Groovy supports inheritance with “extends” and through interfaces (Apache Groovy, 2019). Interfaces are a way for programmers to create abstract classes. They include functions that must be implemented by any class that inherits it. A Groovy programmer may have his class inherit any other class with the same syntax as Java “class A extends class B.”
5.3 Nested Classes
In Groovy, nested classes are called “Inner Classes.” According to the documentation, only the class enclosing the inner class may access it (Apache Groovy, 2019). In addition, the inner class may access every member of the enclosing class including private members, but the enclosing class accesses the inner class in the default fashion.
5.4 Dynamic or Static Binding
Binding is where Groovy stands out from many other popular languages. When it was first released, it was a dynamically type bound language. However, static type binding was added in addition to dynamic type binding in the release of Groovy 2.0 (Apache Groovy, 2019). The release notes for 2.0 say, “Groovy, by nature, is and will always be a dynamic language” (2019). However, the notes say that in order to support Groovy being used in a variety of different ways, they have added the support for static typing and compilation. This gives programmers greater flexibility when writing their code, and allowed for increased performance of the language. The programmer can simply choose what type of binding he would like to use when writing the program, and in a manner of speaking is getting the best of both worlds.
Figure 1. Example of Object Oriented Programming in Groovy
6. REFERENCES
[1] STRACHAN, J. 2003. Groovy – the birth of a new dynamic language for the Java platform. James Strachan’s Radio Weblog. https://web.archive.org/web/20030901064404/http://radio.weblogs.com/0112098/2003/08/29.html
[2] APACHE GROOVY, 2019. Release Notes for Groovy. http://groovy-lang.org/releasenotes/
[3] APACHE GROOVY, 2019. A multi-faceted language for the Java platform. http://groovy-lang.org
[4] INDICTHREADS, 2008. SpringSource Acquires Groovy and Grails Company. http://www.indicthreads.com/2138/springsource-acquires-groovy-and-grails-company-g2one/
[5] PIVOTAL, 2015. Groovy 2.4 And Grails 3.0 To Be Last Major Releases Under Pivotal Sponsorship. https://content.pivotal.io/blog/groovy-2-4-and-grails-3-0-to-be-last-major-releases-under-pivotal-sponsorship
[6] ASF, 2015. Groovy Submitted to Become a Project at The Apache Software Foundation.
[7] BINSTOCK, A. 2013. The Groovy Conundrum. Dr. Dobb’s. http://www.drdobbs.com/jvm/the-groovy-conundrum/240147731
[8] LAFORGE, G. 2007. Groovy 1.0 is there! http://glaforge.appspot.com/article/groovy-1-0-is-there
[9] LAFORGE, G. 2017. JavaOne — How Languages Influence Each Other: Reflections on 14 Years of Apache Groovy. http://glaforge.appspot.com/article/javaone-how-languages-influence-each-other-reflections-on-14-years-of-apache-groovy
[10] APACHE GROOVY, 2019. Differences with Java. http://groovy-lang.org/differences.html
[11] APACHE GROOVY, 2019. Object Orientation. http://groovy-lang.org/objectorientation.html#_inner_class
[12] NASTI, M. 2016. Why Groovy is not that famous? https://michelenasti.com/2016/01/why-groovy-is-not-that-famous/
2019-4-10-1554917729