Groovy 1.6-beta-1 is released

It is with great pleasure that G2One and the Groovy development team announce the first beta of Groovy 1.6.

Beyond the 73 bug fixes and 24 improvements listed in the release notes above, the main focus was on performance improvements.

Compilation and runtime performance improvements

As you may have already noticed with Groovy 1.5.5, the compiler is 3 to 5 times faster than in previous releases. This improvement is available both in this development version and in the 1.5.x stable branch. Thanks to class lookup caches, the bigger the project, the faster the compilation will be.

However, the most noticeable changes will be in the general runtime performance improvements of Groovy. We used several benchmarks from the Great Language Shootout to measure our progress. On those we selected, compared to the current Groovy 1.5.6 stable release, the performance improvements range from 150% to 460%. Micro-benchmarks obviously don't reflect the kind of code you have in your own projects, but the overall performance of your projects should improve significantly.

Beyond delivering stable and quality releases, our main focus over the past 10 months has clearly been on performance.
Between Groovy 1.0 and 1.5.1, on these same tests, we had already gained up to 80% speed improvements, and even between "dot releases" (1.5.1 and 1.5.6) we gained again up to 40% more. However, it's really in the development branch that we've integrated advanced call site caching techniques and bytecode diets in the runtime to get the 150-460% speed improvements mentioned above.

Important new features

Apart from performance related work, bug fixing and minor improvements, let me highlight two new key features which are under development.

Multiple assignments

First of all, I'll mention multiple assignments.

A code sample is always worth a thousand words:

def listOfN(numOfElem) { 0..numOfElem }

def a, b

// variables will contain each successive element of the list
// and variables beyond the count of elements will be null
[a, b] = listOfN(0) // a list of one element
assert a == 0
assert b == null

// if there are more elements, they won't be assigned to any variable
[a, b] = listOfN(9) // a list of ten elements
assert a == 0
assert b == 1

// and you can swap variables with this notation
[a, b] = [b, a]
assert a == 1
assert b == 0

AST Transformations

The other key feature are the AST Transformations. It is more of an advanced feature that is useful for people knowing the internals of Groovy. But fortunately, some practical transformations can be of great interest for Swing developers, for instance.

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. Using annotations to decorate certain classes, fields or methods, a transformation can be applied to the AST of these elements.

A concrete example of the kind of transformations we can achieve with AST Transformations is the new @Bindable annotation. This is particularly useful if you are a Swing developer. See this example:

class MyBean {
    @Bindable String prop
} 

When you decorate a field with @Bindable, property change listener methods will be transparently added to the bytecode of the class, so that you are able to monitor changes to the value of this field without having to manually write those methods yourself. No need to create an addPropertyListener() and removePropertyListener() method anymore, to fire property change events manually in your property setters, etc.

Danno Ferrin gives us an interesting overview of this annotation on his blog.

Other useful and interesting transformations and annotations will be coming in the future.

Annotation definition

Last but not least, as we mentioned annotations above, Groovy 1.5 was still lacking the ability to let us create annotations in Groovy -- they still had to be written in Java. Now it's possible to define annotations in Groovy itself with the usual Java syntax.

Noteworthy remarks

Groovy 1.6-beta-1 is built against JDK 5, but we will provide JDK 1.4 "retro-translated" versions of Groovy.
Note however that you may not necessarily experience the same performance improvements when running on JDK 1.4, as certain enhancements take advantage of JDK 5 (util.concurrent VM optimizations, for instance).
The bytecode generated by the Groovy compiler, as before, still targets the 1.4 JVM bytecode, except for annotations, enums and generics.

Useful links

You can download this new beta here:
http://groovy.codehaus.org/Download

And read the release notes from JIRA here:
http://jira.codehaus.org/secure/ReleaseNote.jspa?projectId=10242&styleName=Html&version=14008

Conclusion

Thanks a lot to all those who have helped us making this release: users, contributors, committers, G2One employees.
This performant and innovative new version wouldn't be the same without all your hard work.
Special thanks to Paul King, Danno Ferrin, Alex Tkachman and Jochen "blackdrag" Theodorou for their commitment and quality work.

We're very interested in hearing about your feedback on this release.
Even if it's not the final 1.6 stable release and that you stick with 1.5.x in production, we would like to know how this beta performs in your respective projects, whether you notice any problem or regression. Please report anything you may find.

Enjoy!

--
Guillaume Laforge
Groovy Project Manager
G2One, Inc. Vice-President Technology
http://www.g2one.com