Groovy types

Java is a statically typed language, which means we have to declare the type of a variable at compile time. Python is dynamically typed. which means that references can never to bound to types at compile time. Groovy on the other hand has optional typing. What this means is Groovy references can be statically typed like in Java, or dynamically typed like in Python.

String staticStr = new String("this is a statically typed String");
staticStr = 8;
println """The type of staticStr is: ${staticStr.class.getName()} """
println """It's value is: $staticStr"""

The output form running the above program is:

String staticStr = new String("this is a statically typed String");
staticStr = 8;
println """The type of staticStr is: ${staticStr.class.getName()} """
println """It's value is: $staticStr"""

As you can see, staticStr remains a string even after it is assigned 8. I will leave it as an exercise to figure out how 8 got assigned to a string type.

//s is not declared to be of any type but holds a String object
def dynamicStr = "this ia a dynamic string"
dynamicStr = 90
println """Type of dynamicStr is ${dynamicStr.class.getName()}"""

The output from running the above code is:

Type of dynamicStr is java.lang.Integer

So, why does Groovy support optional typing? Groovy tries to be feature rich language with support for closures and meta-programming. Both these need Groovy to be dynamically typed. However Groovy also promises compatibility with Java. Hence there are times when we may want it to be statically typed. Groovy takes the unique approach of being an optionally typed language, which allows it to be feature rich and compatible with Java.

I would like to take a little detour here and quote something I read:

"The recent trend is towards dynamically typed languages, which use inference to reduce the amount of code to be written. Java, C# and C++ are "static typed" languages, whereas JavaScript, Ruby, Python and PHP (used by Facebook) use "dynamic typing". In static languages, the programmer must declare each variable's class (such as string, integer, or list) before the program runs; in dynamic typing, it is assessed as the program runs. Fowler says Ruby is between two and five times more productive than Java. "In static languages, there are all these speed bumps. You can just express yourself more rapidly in languages like Ruby and Python, and that gives you an edge. That edge does make a significant productivity difference." - Source: The Guardian

I will not discuss details of static vs. dynamic typing in this blog post, but suffice to say that dynamic typing makes it possible for Groovy to have flexible closures, and metaprogramming. Groovy supports static types to allow inter operation with Java. This is very nice, because not only can a Groovy program take advantage of existing Java libraries, but Java programmers who are not yet fully familiar with Groovy can start Groovy programming with a known paradigm and proceed with closures and metaprogramming as their knowledge of Groovy increases.