In the Spotlight - Guillaume LaForge

This 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 fasterthan 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 overal 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) \{ 1..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(1) // a list of one element
assert a == 1
assert b == null

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

// and you can swap variables with this notation

[a, b] = [b, a]
assert a == 2
assert b == 1

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 pro
}

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!

If you're going to JavaOne this year, and if you're interested in Groovy and Grails, you can't miss G2One's free Groovy / Grails meetup, Monday evening, 7pm, at the W Hotel, across the street from Moscone.

It's going to be a great opportunity to meet the guys behind both Groovy and Grails, learn about the latest news about these projects, see some cool demos, and hear about customers who've decided to use Grails in their projects. You'll be able to also get great Groovy books signed by authors Venkat Subramaniam and Scott Davis.

After an hour and half of keynote, testimonials and cool demos, drinks and apetizers will be provided, and after the break will take place the NFJS meeting with an interesting panel discussion.

So, to recap, we're pleased to invite you to the free Groovy/Grails meetup, on Monday 5th, at 7pm, at the W Hotel, across the street from Moscone.

Please make sure to register to confirm your presence.

This week takes place the 2008 JAX conference, in Germany. Last year, Groovy won the first prize of the JAX innovation award, and this year, Grails was submitted and has just been nominated by the jury. Guillaume Laforge, Groovy project lead and initiator of the Grails project, will be at JAX this week and will represent the Grails team and project.

From the nomination announcement:

Now it is official: The ten nominees for the JAX Innovation Award. The winners of the award are kept top secret and will be made public next week at the JAX. The award, which is endowed with price money of 20,000 Euro altogether, originated from an initiative of the Software & Support publishing company.

Among many submissions from all over Europe our jury has selected these ten contributions. The contribution's innovative value, creativity, elegance and relevancy for practice have been the assessment criteria of the jury.

• Apache Sling
• Biometric Authentification
• GIANTsuite AdCreator
• Grails
• GreenFire
• Intrexx Xtreme 4
• Java business transaction performance management across the entire application lifecycle
• jBPM
• PETA
• Visual Rules Business Rules Management System

It is the intention of the JAX Innovation Award to place inspiring innovations from Europe in the limelight and thus help them to get their chance of success. All interested people can enter this contest. Contributions could be submitted by companies but also by individual people, from research and education or from other organizations that contribute to Java, Eclipse or SOA with their project.

G2One, Inc. and the Groovy development team are pleased to announce the release of Groovy 1.5.5, a bug fix release of the 1.5.x stable branch.

Beyond all the bug fixes and consistency improvements, the major aspect of this release is certainly the improvements in compilation speed. As part of our ongoing efforts to improve the performance of Groovy, we have worked hard on compilation speed, and we backported those improvements from the upcoming Groovy 1.6, to ensure that all users using stable versions of Groovy can benefit from these performance increases. The Groovyc compiler should now be from 3 to 5 times faster, which will make big Groovy / Java and Grails projects much snappier to compile.

A first beta of the upcoming Groovy 1.6 will follow in the coming weeks, and the team focus is still on performance improvements. Groovy 1.6 contains this enhanced compiler, but also brings runtime improvements in many areas, including on number arithmetics where Groovy was known to be slow.

Go download Groovy 1.5.5 and read the changelog for more details on the release.

Sun engineer Matthias Schmidt has just published an article on the progress of the Groovy and Grails support in NetBeans. The Aquarium also features the ongoing work on support of Grails in Glassfish.

On NetBeans front, Matthias Schmidt and Martin Adamek started working on a plugin back in November. You'll need to use a NetBeans nightly build, and download the Groovy/Grails plugin from the updace center. The plugin already provides:

• Method-completion including JavaDoc display for Groovy and Java
• Code Folding of Groovy source files
• Starting, stopping of the Grails server
• Importing existing Grails projects with a week arranged display of project structure
• Groovy/Grails module settings integrated into NetBeans options dialog
• Marking of source code errors
• Easy navigation of Groovy source code by using a navigator view
• Customizing of Grails environment and server port
• Auto-deploy to the Glassfish application server
• Starting common Grails tasks from context menu
• Status of running Grails server displayed in status-line
• Syntax highlighting

• Debugging support
• MultiView for easy navigation between corresponding Model-View-Controller files
• Refactoring support

On GlassFish's side, Eduardo Pelegri reports improvements and bug fixes for running Grails applications in GlassFish and shares a link to the roadmap of the Groovy/Grails support in GlassFish.