

What’s new in Groovy 2.0? - riffraff
http://www.infoq.com/articles/new-groovy-20

======
zmmmmm
Groovy is really quite a remarkable language.

The static compilation and type checking features are quite stunning, and if
they really work as advertised will truly put to rest the last remnants of my
interest in Scala.

I _would_ love to see some more direct support for doing a pure functional
style of programming, but what is there is close enough and so much easier to
grok than Scala, to be honest.

~~~
vorg
Clojure is really quite a remarkable language.

The macros and concurrency features are quite stunning, and if they really
work as advertised will truly put to rest the last remnants of my interest in
Groovy.

I would love to see some more direct support for doing a pure functional style
of programming, but what is there is close enough and so much easier to grok
than Haskell, to be honest.

~~~
zmmmmm
I really don't disagree with anything you've said :-)

However a big point of difference is that Groovy's syntax, being 90%
compatible with Java, is orders of magnitude more accessible than Clojure to
the vast majority of developers.

------
oddthink
What's the current state of Groovy? Has it seen much adoption, compared to
something like Jython or JRuby? Does it have any commonly-acknowledged flaws?

I looked at it years ago, around when it first came out, and it gave me a
negative impression as being sloppily done and a bit amateurish, so I went
with Jython. My impression is that they cleaned up their act and saw decent
adoption, but I don't know any more than that. It seems eclipsed these days in
favor of Clojure and Scala.

~~~
mping
For me, Groovy always have this feeling that's quite the opposite of Scala: it
seems that it was a language that wasn't very thoroughly _implemented_ and has
all of these bolt-on stuff on top of it. Scala seems more solid to me because
of the academic background (to think that a type system can be turing
complete..), and it seems that Clojure found a place on its own.

In general terms, one of the flaws for me is that I can't quite decide what's
the direction that Groovy's going. For example, the 2.0v is introducion static
features, but AFAIK I never noticed any interest on static features (of course
the groovy team should have much more to say on this). Other thing that I
didn't like was the stack traces when an exception ocurred: due to the nature
of the MOP, the stack traces were always very full of 'garbage' (this was some
time ago, I don't know what's the story now). Another example is on the link:
if you want to enable invokedynamic, you have to switch some flag on the
compiler. If you compare to jRuby (which I know is not directly comparable but
as an end user I really don't care) it's alread turned on if you are using the
proper jRuby and JDK versions.

OTOH, I think Groovy nailed the Java interop spot on (flawless Java
invocation/interop, integration with Ant, maven, etc) which is probably one of
the good reasons to use Groovy.

If you consider SO to give a reasonable feedback on popularity, here's the nr
of tagged questions:

    
    
      * scala 549
      * jruby 342
      * groovy 599
      * clojure 120
      * ruby (for comparison) 7,115
    

Having this said, I still think that Grails is one of the best web frameworks
for the JVM, although I would like it more if the plugins would have better
maintenance by the community.

~~~
blktiger
The static features in Groovy 2.0 look like they were integrated from the
Groovy++ project. Seeing as how there was an entire side-project created by
the community I'd say there was a big interest in adding static type checking
to Groovy.

<http://code.google.com/p/groovypptest/wiki/Welcome>

~~~
glaforge
The static features were not integrated from the Groovy++ project, as it
differed in various ways compared to what we had in mind for Groovy. But
Groovy++'s definitely been a great inspiration for us when we developed those
features, and the project clearly showed the interest of the community for
that.

------
enry_straker
To those who knock groovy, just give it a try.

As a long time java user, i was very reluctant to learn groovy and it took
grails for me to really tune into groovy. Now it's really hard for me to go
back to java. :)

I also personally feel that static compilation is more of a marketing sop to
the hard-core java crowd to help move them over to the dark side but what the
hey, if it works, it's good for groovy.

------
lis
Key highlights as stated by Guillaume:

\- a static type checker to let the compiler tell you about the correctness of
your code,

\- static compilation for the performance of the critical parts of your
application,

\- modularity, splitting the Groovy JAR into smaller feature-oriented JARs and
letting you create your own extension modules,

\- JDK 7 Project Coin syntax enhancements, so that Groovy is still as friendly
as possible with its Java cousin,

\- and JDK 7 Invoke Dynamic integration to benefit from the support of the JVM
for dynamic languages.

~~~
jbarmash
Exciting. As a long-time Groovy / Grails user, can't wait to dig in. I think
the new static features make more people coming in from static languages more
comfortable getting into the language. .

------
mgkimsal
I'd heard that groovy 2 would be respecting public/protected/private, as they
could be bypassed with metaclass programming in groovy 1, but haven't kept up
with that in a bit. For example, adding a new method to 'String', in the
example given, looks a bit more work than it used to be, and doesn't reference
the metaclass.

I've got a vested interest in seeing continual uptake of Groovy, but am
wondering what's holding back adoption from those of you who do Java work but
haven't integrated Groovy in to your toolset.

~~~
eweise
I've used groovy in the past on grails projects but haven't adopted it more
because its dynamically typed and slower than java. I have adopted scala as my
main language however, since it can be used as a direct replacement for java.

~~~
zmmmmm
So would the static compilation / type checking features have made a
difference to you in your choice of language?

I'm sort of half in love with the idea, half in horror - I can pick and choose
which parts of my code I want to be static and which parts dynamic - is it the
best of all worlds or a dogs breakfast of incomprehensible and conflicting
paradigms? I don't know, but I think it's one of the first popular and well
established languages to offer this so I consider it really intriguing to see
how it plays out.

------
mindcrime
I'm pretty excited about this, personally. Our startup[1] is building mostly
in Groovy and using Grails, and we've been _very_ happy with the decision so
far. To my mind, one of the biggest knocks on Groovy has been performance, so
it's good to see them moving forward aggressively with taking advantage of
invokedynamic and working to improve performance.

The JRuby guys got quite an improvement out of using invokedynamic, IIRC, so
hopefully this bodes well for the future of Groovy. As others have said,
Groovy is quite remarkable. To date, it remains my favorite JVM language (not
to take anything away from Clojure, Scala, JRuby, Fantom, Nice, Beanshell,
Jython, Kotlin, Fortress, Joy, Ceylon, etc).

[1]: Fogbeam Labs, the up-and-coming Open Source collaboration/knowledge-
management company. <http://www.fogbeam.com> Go there now and sign up for our
newsletter. It's not necessary for you to spend the rest of your day thinking
about how cool Fogbeam Labs are, and how much you want to email all your
friends and tell them about us too. But if you can remember a time when you
were really excited about a company like Fogbeam Labs, then think back to
those feelings and how that made you feel, and do the right thing.

~~~
jbarmash
Agreed. I also chose Grails for my startup 3 years ago, and have been very
happy with decision. Allowed us to deliver a huge amount of functionality
quickly. And Grails 2.0 has been out for six months, that's been great. 2.1
has some nice things in it (about to come out imminently), and I think they
are going to try to get Groovy 2.0 into Grails in 2.2, which will be awesome!

~~~
mindcrime
_and I think they are going to try to get Groovy 2.0 into Grails in 2.2, which
will be awesome!_

Definitely. I'm very much looking forward to Groovy 2 support in Grails. We're
just about to migrate our project to the Grails 2.x series, to start getting
ready for the new hotness.

------
gr8ful
I've been monitoring adoption for some time. There was a (roughly) three+ year
period where Groovy was the fastest growing language in the world. Scala has
seen more growth over the past year, but IMHO it will never challenge Groovy.
Why? Functional languages have been around for years and have never owned more
than a niche market due to their complexity. Groovy is more readable than
Java, and much more readable then Scala or Closure.

Remember COBOL dominated the US for many years due to it's simplicity.
PowerBuilder beat a more comprehensive competitor (SQL Windows) due to it's
simplicity. It seems likely that functional languages may find a niche where
they fit well (e.g. business rules) but languages like Groovy seem most likely
to achieve wide adoption. IMHO of course!

~~~
soc88
It's funny how that "functional" name calling appears so convenient if it fits
the own argumentation. (Not considering that Scala is foremost an object-
oriented language.)

Groovy is trying to play catch-up with Java currently (typing-wise) and I
don't see how they will implement a modern type system in the next decade with
the amount of cruft they have accumulated since Groovy's inception.

Additionally, Java 8 will ship with closures, so I'm not seeing where a niche
for Groovy will remain.

~~~
nithril
As for scala.

------
sarbogast
Yet another step towards massive adoption of Groovy as an alternative to Ruby
and JS for startups. I can't wait to try this out with Vert.x and hopefully
get away with never doing JS on the server.

------
marcpa00
The language has matured and so has the implementation. Static type checking
will reassure those "programming in the large". Static compilation will help
those "programming for the fast lane". A bunch of syntactic simplifications
will help those creating DSL for the so called "business user". Groovy,
Grails, Griffon, Gradle, all on playing well in the JVM ecosystem : this is
exciting !

------
benmccann
I might finally have to take a look at Grails now that there's static type
checking. Do I need to wait for a new release of Grails to use Grovvy 2.0 with
it or can I do that now? Also, I'm curious if it can be turned on globally
when calling the compiler instead of having to annotate all of my classes with
@CompileStatic?

~~~
benmccann
Looks like it'll be in Grails 2.2: <http://jira.grails.org/browse/GRAILS-9225>

------
sjd
Groovy and Grails are both amazing, been doing development for quite sometime
and have tried various languages. Can honestly for a new web based application
I would chose Grails over the others.

------
ilcavero
so what was the performance improvement of invoke dynamic in the end? there
doesn't seem to be any benchmark on the web at the moment.

~~~
mahmud
Amen!

Wont people talk about Invoke-dynamic? how did it work out in the end?

------
nithril
This is a great news. Groovy becomes more and more mature and efficient.

