Since the world didn't seem to end today, it is with great pleasure that we bring under your Christmas tree the following presents: the release of Groovy 2.1.0-beta-1 and Groovy 2.0.6.
- complete invoke dynamic support when running with the "indy" JAR on JDK 7
- upgrade to GPars 1.0: the Groovy distribution now bundles the GPars 1.0 final release
- @DelegatesTo annotation: to help IDEs and the static type checker and compiler to know that method calls in a method parameter closure are delegated to another parameter of the method -- nice for DSLs like in Gradle build files
- custom type checking extensions: so you can type check your DSLs at compile-time with your own logic
- a meta-annotation system: which allows you to define a new annotation actually combining several others -- which also means being able to apply several AST transformations with a single custom annotation
- custom base script class flag for the groovyc compiler: to set a base script class when compiling Groovy scripts
- compiler configuration script: to let you define various configuration options for the Groovy compiler, like specifying custom file extensions, various compilation customizers to apply, etc.
- compilation customizer builder: a special builder for specifying compilation customizers
- jar://, file://, http:// prefix support for launching Groovy scripts from the command line
InfoQ is running a reader-driven research about JVM languages. If you like Groovy, don't forget to vote for us
The Groovy development team is very pleased to announce the release of Groovy 2.0, the highly popular dynamic language for the Java platform.
For the key highlights of this important milestone, Groovy 2.0 comes packed with:
- 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.
To learn more about all those great key new features, please read the Groovy 2.0 article on InfoQ that I’ve written, detailing and explaining all those novelties.
To download Groovy 2.0, go to the download area of the Groovy website.
For further information on all the JIRA issues fixed in this release and the various betas and release candidates, you can have a look at the JIRA changelog.
We’d like to thank all our users, all the contributors and committers who made this important release a reality, thanks to their feedback, their support, and their contributions.
Have a Groovy day!
Guillaume Laforge, on the behalf of the Groovy team.
The Groovy development team is pleased to announce the release of Groovy 1.8.6.
Groovy 1.8.6 is a maintenance release essentially, with a few minor improvements and new features.
You can see the details of the JIRA release notes here:
You can download Groovy 1.8.6 in the Download section of the Groovy website:
Thanks a lot to all those who contributed to this release!
Next in line will a new beta of Groovy 2.0!
GR8Conf are conferences about all the great technologies based on or using Groovy in a way or another. So in other words, that's the grooviest conference you can find, where developers and leads of all the famous Groovy-based projects deliver the latest news and updates about their projects. So be sure to come, learn with them, engage with the community, tell about your usage of those technologies (Grails, Gradle, Griffon, Spock, Gaelyk, etc.)
GR8Conf Europe and GR8Conf US have their Call for Paper still open, for less than a week. So if you haven't yet submitted your proposals, please hurry up!
We're looking forward to having you here!
It is with great pleasure that we are announcing another joint release today!
We have released Groovy 1.8.4, that includes fixes and minor improvements to correct problems the Grails web framework and the Gradle build automation tool were having with 1.8.3.
In addition, we are also pleased to announce the release of Groovy 2.0-beta-1!
Groovy's updated version numbering scheme
Yes, you heard it, a Groovy 2.0 beta! But what's going on, weren't we working on the 1.9 line? Yes, we were, but with the substantial number of new features coming up in the 1.9 release, we thought it was time to start using an updated numbering scheme.
Historically, Groovy's "major" versions have always been "dot" versions, which is a bit uncommon in our industry, in the sense that major versions are expected to have a new major digit each time. So the Groovy version numbering scheme has always been a bit odd for strangers and newcomers -- furthermore, from a marketing perspective, if we ever decide to release a 1.10 version, it would be lexicographically backward (1.10 < 1.9 in math)! This isn't the first time a major change in version numbers has happened: Groovy went from 1.1 to 1.5 and recently Grails changed from 1.4 to 2.0 for its next major release.
So instead of speaking of the mythical "2.0" version of Groovy that never seems to arrive, this next major release will be 2.0. For further versions, we'll probably release some 2.x versions as well, but we will also adopt the same strategy regarding major version numbers, releasing a major version more or less every year. Thus, given 2.0 final should be out in early 2012, the following major version will be released afterwards in 2013 and will become 3.0. But don't worry, we won't adopt the lightning fast numbering schemes of Google Chrome or Mozilla Firefox!
So what will be inside 2.0 that makes it so special?
Static type checking
We have been working on the static type checking support for Groovy.
On several occasions, we have noticed that Groovy was used in Java projects as a simple yet powerful scripting language for Java APIs, in ways that don't particularly leverage the dynamic aspects of the language but instead as a better syntax for Java somehow. With this approach, developers often prefer a stricter approach to type checking, in the sense it should complain when you have typos in your method names, parameters or variables or when you make invalid assignments, etc. The compiler should complain at compile time, rather than having Groovy complain at execution time later on, thus giving you earlier feedback about those errors — particularly useful when you are using APIs that may change.
Static type checking has already been discussed on a few threads on the Groovy mailing-lists, and we appreciate your feedback on how it's being implemented, how it should behave, and so on. Please don't hesitate to come back to us with your thoughts and ideas on this topic.
We have also created a GEP (Groovy Extension Proposal) covering this new aspect:
And Cédric, who joined Jochen and myself at SpringSource/VMware and who's been working on this feature, wrote a very nice and detailed blog post about the current work-in-progress here:http://www.jroller.com/melix/entry/groovy_static_type_checker_status
Be sure to read those two documents, as they will guide you through some interesting samples showing how you can get started using static type checking with Groovy 2.0.0-beta-1! Please also note that this is still in beta, and that APIs are subject to change and evolve depending on your feedback.
With static type checking, type inference capabilities, sensitive flow typing, and so on, the Groovy compiler is now way smarter in figuring out what your code is actually doing. In the case of scripting Java APIs that we mentioned above, we could let the compiler generate direct method calls à la Java, instead of going through Groovy's Meta-Object Protocol, allowing the same performance as Java!
We're going to investigate static compilation in 2.0, leveraging the new smarts of the compiler and its infrastructure, by creating a new git branch with initial support that you'll be able to monitor to watch our progress on that front.
But what about Groovy++?
Thanks to the great work of Alex Tkachman and Roshan Dawrani, the Groovy++ extension project definitely inspired us and ended up convincing us that it was important to support static type checking and compilation in Groovy.
We couldn't simply integrate Groovy++ directly in Groovy 2.0, as it differed in spirit from our ideas for Groovy core, for example by covering more ground than we wanted and needed (persistent collections, new operators, traits, new map-style classes, etc.). We also wanted to evolve the Groovy compiler infrastructure so that it fits nicely with the primitive optimizations work, static type checking and compilation, as well as invoke dynamic support, and we would have needed to refactor Groovy++ heavily for our needs. That said, we of course would welcome collaboration with the Groovy++ team to learn from their experiences building Groovy++.
We engaged the community to discuss various aspects of static type checking and inference so as to make it closer to the usual Groovy semantics as much as possible, without introducing new data structures or restricting existing features (like closures with non-final variables), so that Groovy developers feel at ease with static type checking and compilation, and are the least impacted by differences in semantics between this additional mode and the classical dynamic mode.
Invoke dynamic support
Lastly, we've started working on "invoke dynamic" support, the new JVM bytecode instruction and APIs of JDK 7 developed for dynamic languages, with the goal of improving the performance of all the dynamic aspects of Groovy in significant ways. This is still early days, and this first beta of 2.0 doesn't yet contain particular changes that you'd notice. We are working on the "indy" branch of Git (and mirrored on GitHub) for that support.
And beyond 2.0?
With static type checking and compilation, as well as invoke dynamic support, we thought that it was really worth a Groovy 2.0 moniker! But what's next?
Among the things we want to tackle for 2.x / 3.0 and beyond, we're interested in moving the Groovy grammar from Antlr 2.x to a newer version. Antlr 3 has been available for a while, but our summer attempt at migrating to it haven't been fruitful so far. But we will investigate this move once 2.0 is out, and decide if we go with Antlr 3 or Antlr 4 which should be available when we want to release 3.0.
In the past, we've mentioned several times a redesigned Meta-Object Protocol (MOP 2). With the lessons learned in the invoke dynamic support of Groovy 2.0 and with the ironing out of the invoke dynamic performance of the JIT, we should be able to have a better vision of how to rearchitect the MOP so that it fully takes advantage of invoke dynamic, for faster dynamic features.
There are many other things we'd like to have a look at, but it's still a bit too early to tell what's going to be in Groovy 3 and beyond, as of today. We have time to see what's interesting to add to Groovy to continue helping you being more productive developers, and we will continue to welcome and appreciate your feedback and what you'd like to have in Groovy in the future to simplify your life.
Groovy is what it is today thanks to your ideas and contributions!
You can view the changelog on JIRA for the details:
- Groovy 1.8.4: http://jira.codehaus.org/secure/ReleaseNote.jspa?projectId=10242&version=17852
- Groovy 2.0 beta 1: http://jira.codehaus.org/secure/ReleaseNote.jspa?projectId=10242&version=17925
And you can download the new releases from the usual download area on the Groovy website:http://groovy.codehaus.org/Download?nc
Thanks a lot to everybody involved, and we're looking forward to your feedback!
The Groovy development team
The now famous GR8Conf conference dedicated to all things Groovy, is now coming to Australia, as announced on the GR8Conf blog! It will take place in Canberra, side by side with the Open Source Developers Conference (OSDC), on November 15th.
The GR8Conf Australia website is already up and is running a Call for Papers. So if you have a presentation on Groovy, Grails, Griffon, Gradle, Spock, CodeNarc, Gaelyk, etc, with introductions, deep dives, case studies, and so on, feel free to submit a talk!
We now have a "groovy" organization on GitHub: https://github.com/groovy/groovy-core
Our three main branches have been pushed there: master, GROOVY_1_8_X and GROOVY_1_7_X.
The GitHub repository serves as a mirror, and the Groovy despots will be able to regularly (manually for now) push the latest changes to GitHub, and deal with pull requests and such.
The Groovy website now features a new skin. Make sure to check it out.
In the coming months, we'll work on overhauling the documentation and the website, it's going to be a lot of work and will take a lot of time.
We'll work with a web designer to continue improving the look'n feel of the website, to make it look more profesionnal. We'll try to better organize the information so that it's even easier to search. And we'll look at the 1200 pages worth of documentation to update it where needed, to cover existing holes, etc.