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.
This is with great pleasure that the Groovy development team announces the joint releases of Groovy 1.8.2 and 1.9-beta-3.
The big highlight of this release is the completion of the primitive type arithmetics performance optimizations. Microbenchmarks affictionados should be happy, and those wanting to do some number crunching should see better results with these improvements. Other than that, those two releases are essentially about bug fixes.
You can have a look at the release notes here:http://jira.codehaus.org/secure/ReleaseNote.jspa?projectId=10242&version=17494
And you can download Groovy 1.8.2 and 1.9-beta-3 on the download page:http://groovy.codehaus.org/Download
In other news, thanks to Git expert Matthew McCullough, we completed our complex migration to Git.
You can learn about the details to access and clone the Git repo here:http://xircles.codehaus.org/projects/groovy/repo/git/repo
Later on, we'll also provide a mirror on GitHub.
Small remark on the new beta of the 1.9 branch: due to a glitch a beta-2 was accidentally released in sync'ed with Maven Central, so we bumped the beta number to 3, rather than sticking with 2, as Central won't allow us to override an existing version.
Thank you everybody for your feedback and contributions to those two releases.
I'm very happy to announce the final release of Gaelyk 1.0, the lightweight Groovy toolkit for Google App Engine!
It took some time to get to 1.0, but it's now here, with the key feature I've been missing since the beginning of the project, in particular the Query DSL which allows you to write queries like this one:
If you want to learn more about this lightweight framework, head over to: http://gaelyk.appspot.com/
You can learn everything through the tutorial: http://gaelyk.appspot.com/tutorial
And download the JAR or the template project here: http://gaelyk.appspot.com/download
Should you want to ask questions on the Google Groups, get involved in the community, participate in the development of this Open Source project, have a look at our community page: http://gaelyk.appspot.com/community
This release wouldn't have been possible with all the great contributions of you all, your pull requests on GitHub, your Gradle plugins, your bug reports, your questions on the Google Group, etc. So I'd like to tell you all a big thank you for all your work and contributions. They were very much appreciated, and keep them coming!
The change log:
- GAE SDK updated to 1.5.2 and Groovy to 1.8.1
- Introduction of a Query DSL for creating SQL-like queries against the datastore
- Updated template project with a Gradle build, the usage of Gradle GAE / Gaelyk plugins, and the support of Spock for testing Groovlets
- Introduction of the plugins page in the Gaelyk website, for referencing known plugins
- By annotating classes with GaelykBindings, the same services and variables are injected in your classes as properties, as the ones which are injected in Groovlets and templates
- The validation closures of the routes in your URL mapping have access to the request, so you can validate a URL depending on what's in your request (attribute, session, etc.)
- Added a DSLD file (DSL descriptor) for Eclipse for easing code-completion and navigation
- Added a get() method on Key, as well as on lists of keys
- Ability to convert lists to Keys
- Added two encoded string and key conversion utilities
- Additional datastore.get() methods to retrieve entities by their keys more concisely
- Problems with the recent XMPP support fixed
- Fixed inability to access the various services and variables from within binding/before/after blocks in plugin descriptors
Thanks a lot for your attention, and enjoy developing Groovy applications on Google App Engine!
The Groovy development team is happy to announce the joint releases of Groovy 1.8.1 and 1.9-beta-1.
Both releases feature the following improvements and new features:
- The performance optimizations for primitive type calculations are now covering all the primitive types
- The builtin JSON support adds:
- a streaming builder (StreamingJsonBuilder) for when you want to stream your JSON payload directly to a writer (when you don't need to modify the data structure before outputing)
- and the two builders adds a simple serialization of POGOs/POJOs (just pass the object as a value)
- The groovysh shell supports tab-completion for completing your variables and method names
- Plus the usual GDK refinements that you can find on the release notes below.
And the first beta of the upcoming 1.9 line is adding on top of that:
- Most of Java 7 Project Coin enhancements:
- Use underscores in number literals:
- Binary literals:
- Catch multiple exceptions at once with multicatch:
catch (IOException | NullPointerException e)
- Use underscores in number literals:
You can learn more about the tickets closed for these issues here:
And of course, you can download Groovy 1.8.1 and Groovy 1.9-beta-1 in our download area.
Keep on groovying!