Groovy 1.6-beta-1 is released

[glaforge]

Hi all,

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 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 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) { 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

[Daniel.Sun]

I tested the performance of groovy 1.6 beta-1 with the following code
                               1      2      3      4        5       6      7      8       9     10            AVG
Groovy1.5.6GA   :  1360  1156   969  1000  1063  1110   938  1046  1031   954        1062.7
Groovy1.6.0BETA1:  187   171    141   109   187    156   172    141   203   187          165.4

As the result shows,
the performance of groovy1.6beta1 is improved by 84.4% compared with Groovy1.5.6GA

It's quite amazing!

I have developed apps in Groovy for about 2 years, today I'm especially excited !
Thanks for your hard work, Groovy dev team!

Cheers,
Daniel.Sun
------------------------------------------------
q = 8
i = new int[q]
count = 0

def scan(n){
    if (n == q){
        println(i.toList())
        count++
        return
    }
    i[n]=0
    while (i[n] < q){
        i[n] = i[n]+1
        if (check(n))
            scan(n + 1)
    }
}
def check(n){
    if (n > 0)
        for (j in 0..<n)
            if (i[j] == i[n] || i[j] - i[n] == j - n || i[j] - i[n] == n - j)
                return false
    return true
}

long t1 = System.currentTimeMillis()
scan(0)
long t2 = System.currentTimeMillis()
println("total time:" + ( t2 - t1))  
println("total results:" + count)

glaforge wrote:

Hi all,

This is with great pleasure that G2One <http://www.g2one.com> 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 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) { 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<http://shemnon.com/speling/2008/04/bindable-observable-properties.html>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

[Daniel.Sun]

the code attached is to solve the famous 8 queen problem.


I tested the performance of groovy 1.6 beta-1 with the following code
                               1      2      3      4        5       6      7      8       9     10            AVG
Groovy1.5.6GA   :  1360  1156   969  1000  1063  1110   938  1046  1031   954        1062.7
Groovy1.6.0BETA1:  187   171    141   109   187    156   172    141   203   187          165.4

As the result shows,
the performance of groovy1.6beta1 is improved by 84.4% compared with Groovy1.5.6GA

It's quite amazing!

I have developed apps in Groovy for about 2 years, today I'm especially excited !
Thanks for your hard work, Groovy dev team!

Cheers,
Daniel.Sun
------------------------------------------------
q = 8
i = new int[q]
count = 0

def scan(n){
    if (n == q){
        println(i.toList())
        count++
        return
    }
    i[n]=0
    while (i[n] < q){
        i[n] = i[n]+1
        if (check(n))
            scan(n + 1)
    }
}
def check(n){
    if (n > 0)
        for (j in 0..<n)
            if (i[j] == i[n] || i[j] - i[n] == j - n || i[j] - i[n] == n - j)
                return false
    return true
}

long t1 = System.currentTimeMillis()
scan(0)
long t2 = System.currentTimeMillis()
println("total time:" + ( t2 - t1))  
println("total results:" + count)

glaforge wrote:

Hi all,

This is with great pleasure that G2One <http://www.g2one.com> 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 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) { 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<http://shemnon.com/speling/2008/04/bindable-observable-properties.html>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

[Jason Dillon]

Where is the groovy-all-minimal artifact for 1.6-beta-1?  I see groovy-all ( http://repo1.maven.org/maven2/org/codehaus/groovy/groovy-all/1.6-beta-1/ ) but don't see anything for 1.6-beta-1 here:

    http://repo1.maven.org/maven2/org/codehaus/groovy/groovy-all-minimal/

--jason

On May 3, 2008, at 5:38 AM, Guillaume Laforge wrote:

Hi all,

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 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 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) { 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

[AxiomShell]

Great news!

Congrats on the excellent work.

---------------------------------------------------------------------
To unsubscribe from this list, please visit:

    http://xircles.codehaus.org/manage_email

[Isaac Gouy]

On May 2, 10:17 pm, "Daniel.Sun" <realblue...@...> wrote:
> I tested the performance of groovy 1.6 beta-1 with the following code ...


The Computer Language Benchmarks Game now shows Groovy Version: 1.6-
beta-1 JVM: 1.6.0_06

http://shootout.alioth.debian.org/gp4sandbox/benchmark.php?test=all&lang=groovy&lang2=groovy


As you can see some of the programs show Error, apparently that's
something to do with the old way they are written - main method and
variables not "def"-ed

Also there are some missing programs, and even the programs that do
not show Error were written quite a long time ago.

We hope better Groovy programs will be contributed, please follow the
FAQ instructions - http://shootout.alioth.debian.org/gp4sandbox/faq.php#play



---------------------------------------------------------------------
To unsubscribe from this list, please visit:

    http://xircles.codehaus.org/manage_email

[Alex Tkachman]

Isaac, what is command line used to run Groovy tests?

On Sun, May 4, 2008 at 4:19 AM, Isaac Gouy <igouy2@...> wrote:

>
>
>  On May 2, 10:17 pm, "Daniel.Sun" <realblue...@...> wrote:
>  > I tested the performance of groovy 1.6 beta-1 with the following code ...
>
>
>  The Computer Language Benchmarks Game now shows Groovy Version: 1.6-
>  beta-1 JVM: 1.6.0_06
>
>  http://shootout.alioth.debian.org/gp4sandbox/benchmark.php?test=all&lang=groovy&lang2=groovy
>
>
>  As you can see some of the programs show Error, apparently that's
>  something to do with the old way they are written - main method and
>  variables not "def"-ed
>
>  Also there are some missing programs, and even the programs that do
>  not show Error were written quite a long time ago.
>
>  We hope better Groovy programs will be contributed, please follow the
>  FAQ instructions - http://shootout.alioth.debian.org/gp4sandbox/faq.php#play
>
>
>
>
>
>  ---------------------------------------------------------------------
>  To unsubscribe from this list, please visit:
>
>     http://xircles.codehaus.org/manage_email
>
>
>

---------------------------------------------------------------------
To unsubscribe from this list, please visit:

    http://xircles.codehaus.org/manage_email

[Jason Dillon]

Any idea why 1.6-beta-1 is about 1 megabyte larger than 1.5.6?

--jason

On May 3, 2008, at 5:38 AM, Guillaume Laforge wrote:

Hi all,

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 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 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) { 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

[Isaac Gouy]

--- Alex Tkachman <alex.tkachman@...> wrote:

> Isaac, what is command line used to run Groovy tests?

You can see the command line used to run a program at the bottom of the
source code page

http://shootout.alioth.debian.org/gp4sandbox/benchmark.php?test=partialsums&lang=groovy&id=0#log


      ____________________________________________________________________________________
Be a better friend, newshound, and
know-it-all with Yahoo! Mobile.  Try it now.  http://mobile.yahoo.com/;_ylt=Ahu06i62sR8HDtDypao8Wcj9tAcJ

---------------------------------------------------------------------
To unsubscribe from this list, please visit:

    http://xircles.codehaus.org/manage_email

[Jochen Theodorou]

Jason Dillon schrieb:
> Any idea why 1.6-beta-1 is about 1 megabyte larger than 1.5.6?

because we have some generated code in the jar. And of course other code
was added as well

bye blackdrag

--
Jochen "blackdrag" Theodorou
The Groovy Project Tech Lead (http://groovy.codehaus.org)
http://blackdragsview.blogspot.com/
http://www.g2one.com/

---------------------------------------------------------------------
To unsubscribe from this list, please visit:

    http://xircles.codehaus.org/manage_email

[Yegor]

>
> 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.
>

Unfortunately, in my project 1.6-beta1 seems to perform worse than
1.5.4, numbers below are time in seconds:

1.5.4:
Build (in fact, everything is built already):
21 20 20 20 20

Test all:
318 287 287 287 288

Start:
20 21 20 20 22

Build, start, exit:
41 44 44 43 43


1.6-beta1:
Build (in fact, everything is built already):
23 23 20 22 22

Test all:
329 353 346 350

Start:
36 32 31 31 33

Build & Start & Exit:
60 58 60 56 58

It's a Netbeans Platform application with 50% of code in Groovy. All
test-cases are for Groovy part and there are no changes in terms of
pass/fail, only performance changed.
Test platform: 2Gb RAM, Core Duo 2 2GHz, 7200 RPM HDD, Ubuntu 8.04,
java 1.5.0_15-b04, Netbeans 6.1 development version 080512

--
Best regards,
Yegor
__________________________________________________________
Yegor Bryukhov,
Research Associate
Center for Algorithms and Interactive Scientific Software
City College of New York

---------------------------------------------------------------------
To unsubscribe from this list, please visit:

    http://xircles.codehaus.org/manage_email

[glaforge]

Would you have some kind of subset of your application that we could
use as a benchmark somehow for future performance improvement work?

On Mon, May 12, 2008 at 9:02 PM, Yegor Bryukhov <ybryukhov@...> wrote:

>>
>> 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.
>>
>
> Unfortunately, in my project 1.6-beta1 seems to perform worse than
> 1.5.4, numbers below are time in seconds:
>
> 1.5.4:
> Build (in fact, everything is built already):
> 21 20 20 20 20
>
> Test all:
> 318 287 287 287 288
>
> Start:
> 20 21 20 20 22
>
> Build, start, exit:
> 41 44 44 43 43
>
>
> 1.6-beta1:
> Build (in fact, everything is built already):
> 23 23 20 22 22
>
> Test all:
> 329 353 346 350
>
> Start:
> 36 32 31 31 33
>
> Build & Start & Exit:
> 60 58 60 56 58
>
> It's a Netbeans Platform application with 50% of code in Groovy. All
> test-cases are for Groovy part and there are no changes in terms of
> pass/fail, only performance changed.
> Test platform: 2Gb RAM, Core Duo 2 2GHz, 7200 RPM HDD, Ubuntu 8.04,
> java 1.5.0_15-b04, Netbeans 6.1 development version 080512
>
> --
> Best regards,
> Yegor
> __________________________________________________________
> Yegor Bryukhov,
> Research Associate
> Center for Algorithms and Interactive Scientific Software
> City College of New York
>
> ---------------------------------------------------------------------
> To unsubscribe from this list, please visit:
>
>    http://xircles.codehaus.org/manage_email
>
>
>

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

---------------------------------------------------------------------
To unsubscribe from this list, please visit:

    http://xircles.codehaus.org/manage_email