Opinions expressed in this post are totally my own and not necessarily that of my employer.

Wednesday started with the infamous “scriptbowl”, a competition between various scripting languages. This year the contenters were JRuby, Groovy, Scala, and Clojure. I wondered whether Scala considers itself a scripting language but obviously they either do or just seek the opportunity to be on stage.

To keep a long story short: Groovy has won this event for the third time in a row! This year the race was tied with Scala. Guillaume presented Groovy in the typical Groovy-idomatic style and explained every single line of his concurrent visual analyzer for Google+ postings. Dick Wall presented only non-idomatic Scala code. I interpret this as: to make Scala appealing you have to make it look like Groovy. Furthermore, he presented Kojo, which is a great interactive learning environment written in Play/Scala. In contrast to all other presentations, this was not specifically created for the scriptbowl, nor was it written by the presenter, nor was it clear how much effort went into it, nor did the audience see a single line the implementation code. How much this skewed the comparison, I leave to everybody’s judgement. The show was good, though.

I felt a bit sorry for Clojure. It is a great language and deserves a presentation that is more visually appealing to convince the crowd.

Afterwards, I attended a hands-on lab for “rapid enterprise development with netbeans”, which was essentially creating a Swing app for database CRUD actions. If I remember correctly, I did the exact same task 1997 with JBuilder. It left me with the feeling of “Yes, it works” but it is not less complex than it was 13 years ago.

Early afternoon Gerrit Grunwald (better known as @hansolo_) presented his work on simplified custom components for Swing. Given that he speaks about an activity that is both utterly important and highly underadvertised he would really deserve speaking at the center stage.

Graeme Rocher’s great session about Grails, polyglot datastores (hibernate, jpa, redis, mongodb, …), and the cloud was overshadowed by the news that Steve Jobs has died. Accidentally, the demo application was about showing a BBC News stream, which displayed this information live on stage. Both the presenter and the audience were equally touched.

The day officially ended with a big event at treasure island. I decided to not go there, though, and meet the former Canooey Denis Antonioli in Berkely where we had a great evening.

Dierk Koenig

Last week I sat down with the gang at the Grails Podcast and talked shop for about 45 minutes. We talked about a lot of different topics such as Groovy, Lean software, Spock, Groovy in Action, and of course Hackergarten. Check out the full audio and shownotes over at Grails Podcast Episode 125.

The formal release of IntelliJ IDEA 10.5 came out this month, and the new Groovy features are all part of the free and open source Community Edition, and the Grails features are part of the Ultimate Edition. IDEA X (or 10 to you non-Romans) was a larger release of the product, and I already blogged about IDEA X for Groovy and IDEA X for Grails. There’s still plenty of nice features in 10.5 though. The prices for IDEA recently dropped between $100 and $50, and anyone purchasing IDEA since last November gets 10.5 as a free upgrade.

Here’s what 10.5 is all about (or skip straight to the release notes).

Groovy 1.8 Support
A big push in IDEA 10.5 was Groovy 1.8 support. Groovy 1.8 contains many compile time AST transformations that do things like write out new methods and fields into the Groovy .class files. Normal IDEs will show in-IDE compile errors when using these annotations yet still allow you to compile and execute the script. This has been fixed in IDEA, so the IDE should give you proper code completion and support when you use @Field, @TupleConstructor, and @Log. This is especially helpful when invoking these synthetic members from Java code.

Introduce Parameter and Introduce Field Refactorings
Introduce Parameter is one of my favorite refactorings. Select a local variable within a method, press Ctrl+Alt+P, and the local variable is extracted into a method parameter. It doesn’t yet work for closures, but you can vote for that feature. Introduce Field is also handy: select a local variable in either a method or a closure, press Ctrl+Alt+F, and the local variable is extracted into a field on the enclosing class. IDEA is not capable of extracting a field in a script yet, which would logically create an @Field script field, but feel free to upvote the issue.

Go To Test (and vice versa) Support
Tests and production source follows a naming convention, for example MyClass and MyClassTest. You can now press Ctrl+Shift+T to jump to the test (if you’re in production code) or jump to the production code (if you’re in the test). And if there is no test, then it will prompt you to create a new one. This works great in most cases. Of course, with Groovy it is not so rare to have several top-level classes in a single source file. In these cases the feature can sometimes get confused. Upvote the fix here if you want it to be just that much smarter in the future.

More Code Completion and Intentions
The “add static import” intention is nice for those who use a lot of static imports. Just set your cursor in a constant referenced from your code, press Alt+Enter, and viola… the constant is statically imported. Also, code completion is now available when creating an object using named parameters, which makes them a little easier to use. A whole bunch of other code completion issues were fixed as well, but these were technically marked as bugs not features. You can always peruse the release notes to see the whole story.

Performance
JetBrains claims that file indexing (typically at IDE startup) is now faster and that working with large Groovy files is more performant. It is hard for me to see a difference since I use the EAP versions and don’t currently work on any massive projects currently.

Grails Code Generation & Completion (Ultimate Edition)
Some small but nice things here. If you reference a controller action from a GSP, and that action does not exist, then pressing Alt+Enter creates an empty action for you. Also, the type inference for values on the GrailsPlugins has been improved, such as the closure parameters for doWithApplicationContext, doWithDynamicMethods, etc, and code completion for controllers and action in custom plugins are now discovered automatically. Finally, the code inside <r:script> tags from the Grails Resource plugin is now parsed as JavaScript, so full IDE JavaScript is available within them. This is supposed to become a standard for Grails 1.4, so it should continue to work with that release.

Improved Grails Resource Bundle and i18n Support
With 10.5, if you reference a property using the <g:message> tag in a GSP, and that property does not exist, then the property will be underlined in red and you’ll be given an Alt+Enter Intention to create it for you. Nifty. Also, the existing i18n intentions should now work better when you have GString syntax in your text. For instance, the string “Hello, ${user}” should now be properly handled when extracting to a resource bundle.

Various Usability Improvements
Last on the list are a few odds and ends around usability. Closures can now have the separator line between them in the IDE, the way methods show a line between them. GSP stacktraces have correct (and clickable) hyperlinks. The scripts folder is visible in the Grails view. And code navigation and formatting has been improved for several Grails Artefacts.

That’s it. Enjoy the upgrade, may your solid state disk never fail, and may your caches always be valid. Caio!

If you like this sort of thing, then there is also a whole bunch of other IDEA related content on my own blog and on the Canoo blog. Enjoy.

As promised, here are some more strategies I use when navigating inside IDEA.

Please note that this is for Groovy and Grails development on Mac OS X with Swiss-german keyboard layout, so the keybindings may differ on your machine. (For Windows, you most often can replace Cmd with Ctrl)

Alt F1 “Select in…”

is your friend when you are in a file or class and you have lost track on where in the project this file lives or you want to navigate in the “neighborhood”. You get a selection like below

From this selection, I most often choose the project view, which is even quicker accessible via Cmd 1 (like all the numbered toggle buttons around your frame can be reached via Cmd number).

When I started working with IDEA, I used the project view pretty much like a Windows Explorer or Mac Finder. But it is actually much more versatile. Especially when working with Grails, where you have quite a number of different source roots, it is interesting to switch to the package view, e.g. to see production classes and their tests beneath each other.

Moreover, in the project view – just like in any other tree view in IDEA – you can simply start typing and this will select the closest match in the tree! For example like so:

This can speed up your navigation dramatically.

But you can even spare using the project view (for better screen real-estate) with the Navigation Bar.

Fn Alt left-arrow (or Alt-Home but I have no Home key on my MBP)

jumps to the navigation bar like so:

You can now use the left/right arrow keys to “cd” up/down, use up/down arrow keys to make your choice of file or subdir.
I discovered this functionality only recently but I must say that I like it very much. It keeps the maximum space available for the code. What could be better?

This brings me to the point that ESC always brings you back to the editor (returns from any tool window) and Shift ESC does the same but closes the tool window and double clicking the editor tab closes all tool windows and allows maximum space for your code editors.

When navigating through many classes, one easily opens a lot of editors – more than can be displayed. I ususally keep the allowed number of open editors pretty low, since with many open editors it is anyway too tedious to find the one that I am looking for. I rather use

Cmd E

to show the list of all recent editors or

Cmd Shift E

to show the list of all recently changed editors.

F11

toggles a bookmark for the current line and

Shift F11

allows navigating to any bookmark, including a preview. I like to use bookmarks a lot and use them as reminders for things to do before committing.

Gutter icons (that is the area just left to the beginning of code lines)

allow quick access to superclasses and subclasses (also on method level).

Interestingly, this is not a lot of different devices for navigating around, but those are the ones that are sufficient for me. I hardly never use the “UML” tab below each editor, even though the graphical hierarchy-based navigation works as good as all the other hierarchy views and tools. Well, I avoid complex inheritance structures in my code anyway…
I also tried Ctrl Tab for the “Switcher” (while holding down Ctrl use Tab and Alt to make selections) but this doesn’t really align with my style of working.

Later, I will also talk about various search and inspection capabilities, which can also be seen as means of navigation.

But the next post will be about avoiding navigation at all – meaning you get the information without leaving your current edit location.

keep groovin’
Dierk

I have used IntelliJ IDEA since 2001 and I’m happy to share some of my experiences, useful shortcuts, lesser-known features, and useful personal settings. My descriptions apply to using IDEA X Ultimate almost exclusively for Groovy and Grails development on Mac OS X with Swiss-german keyboard layout, so the keybindings may differ on your machine. (For Windows, you most often can replace Cmd with Ctrl)

It is very tempting to show a looooong list of features and keybindings, but I rather keep the list very short to make it easier to digest, remember, or try yourself right away.

Let’s start with how I typically navigate the project.

Cmd N

Finds a class by Name. As with any lookup facility in IDEA, you can provide only parts of the classname, camel-case abbreviations, and wildcards. When the class is not found in the project, the libraries are searched.

Cmd Shift N

Same as Cmd N, but for files by Name in the project, instead of classes. The “Shift”ed version of a short can generally be translated to “smart”.

Cmd Alt Shift N

I can hardly overemphasize how much I like that one! It’s a smart search for any member (field, method) in your codebase. And it is fast! How often did I asks myself: “I know there was a getMy<Something> method in the code somewhere, but where was it?” This shortcut has the answer.

Cmd click or Cmd B

To jump to the definition of the symbol under the cursor.

Once you have navigated to some information, you often want to navigate back to your starting point. You can use

Cmd Alt left/right

to navigate back and forth the navigation history or

Cmd Shift Backspace

to bring you back to the last edit point. I use that all the time. And it also has a history, i.e. when you hit the shortcut twice, it will bring you back to the last-but-one edit point.

You can cover quite some ground with only these basic operations.

In the next post of this series, I will show some even more advanced navigation techniques.

keep groovin’
Dierk

The new version of IntelliJ IDEA was released last week. I already blogged what IDEA X means for Groovy developers, and all of those features are obviously available to any Community Edition user (that’s the free one). This post looks at all the new Grails features available in the Ultimate Edition (the one you pay for). These features are a little harder for me to try out personally as my current project is EJB3 and not Grails (someone save me please!). I’ve tried quite a few of them personally, but feedback is always welcome in case I miss or exaggerate something. Without further ado:

Grails Aware IDE Features

Better MVC Rename Refactoring – Related artifacts are now renamed together, such as renaming a view when renaming a controller action, or renaming test cases when the main class changes (IDEA-45378).

Functional-Test Plugin Support – The Functional-Test plugin got some love, and support is the same as normal unit and integration tests (IDEA-51853). Testing is good.

Filter Support – There is a new action to easily create filters, code completion of actions and controllers works within the filter mapping code, and method like render() and getRequests() resolve from the filter body (IDEA-60331 and IDEA-60167).

Mapping DSL Support - In domain class mappings you now get code completion that is aware of HibernateMappingBuilder, and the rename refactoring is aware of the mappings (IDEA-49089.

Constraint DSL Support – Domain object constraints definitions now have code completion on common constraint names, completion on field names, and is correctly updated when using the Rename refacotring (IDEA-49115).

Service and Bean Inference – The names and types of services and beans can be inferred in controllers and other artifacts (IDEA-49111 and IDEA-45610).

GSP and View Improvements

Easy Internationalization – I love this. There’s a new intention in GSP files to move a static string into a message bundle. Alt+Enter does the trick. IDEA-44846 and IDEA-59519

Groovy Inspection Support – In the past, only some Groovy inspections worked in GSP files. Support for more of the inspections have been added, like “divide by zero”, “double negation”, and “unresolved expression”. It’s not clear if all inspections are supported, but at least more are IDEA-50414

Better Variable Resolution – References to controllers and controller properties are now resolved within GSP view pages. I assume this means at least control click navigation and code completion. See IDEA-49731 and IDEA-48692. Also, release notes claim “Completion for value of action/controller parameters in built-in methods redirect(), render(), forward(), chain()”.

g:fieldValue Support - g:fieldValue tags reference a field. Rename, completion, and find usages should all now work within the tag. IDEA-60858

Debugging in GSP - Release notes claim “Preliminary debugging of GSP pages”. Not 100% sure what this means in practice.

JavaScript in Tags – Release notes claim “support javascript in tags like “onSuccess”, “onFailure”, etc”. Again, I’m not sure what this means in practice.

Find Usages

Domain class fields - Find usages for domain class fields has been improved. The ticket indicates that usages of fields within GORM dynamic queries are now supported (IDEA-58025).

Variables from tags – Find usage support for variables defined using a g:set tag within a GSP (IDEA-58185).

Property Usages - i18n message properties are now included in Find Usages, and the corresponding “unused property” inspections should be working (IDEA-52117).

Even More Code Completion – Besides what’s already been mentioned, we also have…

Model Aware GSPs - Related to above, views are now aware of which model is returned from the controller, and autocomplete works for them. More info at IDEA-40926

Variable Aware GSPs – When you define a variable in a GSP then IDEA now autocompletes it and stops pestering you for missing imports IDEA-50257

Attribute Aware GSPs – Finally, code completion and navigation exists for the standard attributes: “action”, “controller”, “template”, “contextPath”, “plugin”, and well as variables defined in tags like g:each, g:set, etc.

And more, and more, and more – There’s practically too many to list. Code completion works in type convertors, in named queries, in URL Mappings and their GSP attribute values, in scope objects like servletContext, session, request, params, and flash (they also appear in the debugger as well), in views references from ‘render’ and ‘redirect’ controller calls, and in hasOne mappings which was missed in the last release.

Grails Framework Support

Gant Script Support - IDEA is now aware than .groovy files in the scripts directory are Gant scripts. Targets are completed and imports are resolved better (IDEA-49738).

Grails Target History - Running a Grails target brings up a dialog box. You can now use up and down arrow to scroll through your history (IDEA-46943).

Ivy Integration – IDEA reads your Ivy cache and automatically loads source and javadoc jars if they’re available (IDEA-53294).

UI Improvements – The “Browse to http://localhost:8080/xxx” message in the console now lets you click it to open a browser (IDEA-47166), the test console allows keyboard input in case your tests read from standard input (IDEA-57035), the gutter of controller actions show an icon that lets you jump to the corresponding view (IDEA-49320, and the “New” menu now has context sensitive sorting (IDEA-49086). How’s that for productivity boosting?

I believe that covers it. If you want a free IDEA Ultimate license then there are ways to get them… speaking at your local Java/Groovy Users Group is usually the easiest, and many JUGs have giveaways if you feel lucky. If your group isn’t sponsored by JetBrains then you can always ask: email jugs@jetbrains.com!

Happy Holidays everyone. I’m hoping Santa brings IDEA 10.1.

Groovy CodeNarc is a static analysis tool for the Groovy language and does for Groovy what PMD and FindBugs does for Java: it analyses Groovy code for defects, mistakes, and bad practices. The new version 0.11 is a huge release for us. We’ve added over 50 new rules to the product (bringing the total to 130+ rules) and a few really great features. This is THE new look CodeNarc, and it’s ready to use today in beta form using the CodeNarc Web Console with the release coming by Monday, and we’ll be updating the Grails, Gradle, and Griffon plugins shortly. This post explains a few of my favorite new rules and features, and explains how you can help out. You can play with all the new rules today in the CodeNarc Web Console, so if you find any rule misses, false positives, or just new ideas then save the script and drop us an email! So here is my list:

@SuppressWarnings Support
All rules now recognize the java.lang.SuppressWarnings annotation on fields, methods, and classes. If this annotation is added then there will be no violations produced. This is great for the times when you really do want to ignore a rule or in the rare case where you find a false positive. Just as in Java, the annotation requires a String or List parameter. For example, annotating a class with @SuppressWarnings(‘UnusedPrivateField’) will ignore the rule for that class. Annotating a method with @SuppressWarnings(['UnusedPrivateField', 'UnnecessaryIfStatementRule']) will ignore both rules for the annotated method.

New Rules: Should use Operator not Method Call
Groovy supports Operator Overloading. “a.plus(b)” should be written as “a + b”. Likewise “a.minus(b)” should be “a – b”. Every single operator overloading in Groovy is supported: And, or, CompareTo, GetAt, etc., etc. This is great for newcomers (and old-timers) who often revert back to the Java way of doing things without realizing it. Check out these rules in the basic ruleset of the CodeNarc docs for more information: ExplicitCallToAndMethod, ExplicitCallToCompareToMethod, ExplicitCallToDivMethod, ExplicitCallToEqualsMethod, ExplicitCallToGetAtMethod, ExplicitCallToLeftShiftMethod, ExplicitCallToMinusMethod, ExplicitCallToMultiplyMethod, ExplicitCallToModMethod, ExplicitCallToOrMethod, ExplicitCallToPlusMethod, ExplicitCallToPowerMethod, ExplicitCallToRightShiftMethod, and ExplicitCallToXorMethod,

New Rules: Explicit Creation of Collection Types
We all know the “[]” is an ArrayList and “[:]” is a HashMap. Do you know the syntax for Sets, HashSets, LinkedList, Stack, and TreeSet as well? CodeNarc does, and will tell you when you explicitly create an object of this type instead of using the Groovy shorthand. You’d be surprised how often it catches you out. Check out these rules in the basic ruleset of the CodeNarc docs for more information: ExplicitCreationOfArrayList, ExplicitCreationOfHashMap, ExplicitCreationOfHashSet, ExplicitCreationOfLinkedList, ExplicitCreationOfStack, and ExplicitCreationOfTreeSet

New Rules: Null Safety
Null stinks, don’t use it. Easier said then done and hand-rolling an option type will raise the eyebrow of even the most hardened Scalar. So here are some rules: if your method returns a collection or map, then never return null. Return an empty collection instead. It makes the calling code a lot prettier to not worry about the null checks. Likewise, don’t return null from Boolean methods or CatchBlocks. They are accidents waiting to happen. The cool thing about these rules is that they analyze methods and closures to infer return types. It doesn’t just look at the method signatures it discovers the return type using type inference. We’re trying to make this more powerful and have even swapped some ideas with the groovy++ guys to see what we can share. In the meantime, check out these rules: BooleanMethodReturnsNull, ReturnsNullInsteadOfEmptyArray, ReturnsNullInsteadOfEmptyCollection, and ReturnNullFromCatchBlock

New Rules: Useless Constructs and Dead Code
Code can appear after a return or throw statement, but you should probably delete it. The Dead Code Rule helps you here. But many other things are pointless as well, such as double negatives in boolean expressions (DoubleNegative Rule), supplying a default constructor as your only constructor (UnnecessaryConstructor Rule), various useless calls on collections like “x.containsAll(x)” (UselessCollectionCall Rule), overriding a method only to call super() as your single line implementation (UselessOverridingMethod Rule), and return keywords in general (UnnecessaryReturnKeyword Rule).

New Rules: JUnit Clarity Rules
xUnit Patterns is a great book, but who has time to read the 800 page tome? No worries, we mined the text for good Junit rules. Don’t bother reading, just configure CodeNarc to do the learning for you. The UseAssertEqualsInsteadOfAssertTrue makes sure you use assertEquals instead of assertTrue with an explicit .equals() invocation, and UseAssertTrueInsteadOfAssertEqualsRule does the opposite: use assertTrue instead of assertEquals(true, …). You can guess what the rules UseAssertNullInsteadOfAssertEquals and UseAssertSameInsteadOfAssertTrue do. Also, using the fail() method instead of fail(String) obscures test failures. UseFailWithMessageInsteadOfWithout makes sure you don’t use it. Lastly, you may want to abandon JUnit entirely and use Groovy Power Asserts. We have you covered with JUnitStyleAssertions.

New Rules: Naming and Inheritance Problems
Some simple rules… don’t name a class Exception if it doesn’t extend Exception (ConfusingClassNamedException Rule). Don’t name fields, methods, or closures with names that differ only in capitalization (ConfusingMethodName Rule), and make sure that methods subclassed off Object are spelled correctly (ObjectOverrideMisspelledMethodName Rule).

And many other rules:
OK, I don’t want to leave any out, so here are the other rules included in the release:
The DuplicateCaseStatement Rule check for duplicate case statements in a switch block, such as two equal integers or strings. The GStringAsMapKey Rule checks that GString are not used as a map key since its hashcode is not guaranteed to be stable. The InvertedIfElse Rule checks for an inverted if-else statement, which is where there is a single if statement with a single else branch and the boolean test of the if is negated. The SerialVersionUID Rule checks for a serialVersionUID field that is not long, static, and final. The RemoveAllOnSelf Rule checks that you don’t use removeAll to clear a collection which is unsafe.

The SynchronizedOnGetClass checks for synchronization on getClass() rather than class literal which is again unsafe. The UseOfNotifyMethod Rule Checks for code that calls notify() rather than notifyAll() which is also usually unsafe. And the CatchIllegalMonitorStateException Rule checks for catching IllegalMonitorStateException which is usually a sign of faulty multithreading and interruption logic.

The last few are MethodCount Rule which checks if the number of methods within a class exceeds the maximum (configurable), the DuplicateNumberLiteral Rule which checks for duplicate number literals within the current class, and the DuplicateStringLiteral Rule which checks for duplicate String literals within the current class.

If you turn on all of these rules I am sure you will have hundreds if not thousands of violations. That’s a good thing!

How to Help
Yes, we need your help. We want 50 more rules for the next release. Here’s some ideas to help for those without much time.
Got 2 Seconds? – Vote for the IntelliJ IDEA feature request to support CodeNarc in the IDE.
Got 1 Minute? – When you find a false positive then head to our Bug Tracker and enter a ticket.
Got 2 Minutes? – In your next code review write down one of the problems you found and the correct fix. Email it to me at hamletdrc@gmail.com or just save the script in the CodeNarc Web Console. I’ll create a rule for it. Could be a bug, an idiom, or just a preference.
Got 5 Minutes? – Take the issue from your code review and brainstorm some edge cases. Then head to our Bug Tracker and enter a ticket.
Got an Hour? – Write a rule. It’s simple and automated. Checkout the source, do a “mvn clean install” from the root, and run “groovy codenarc.groovy create-rule”. You’ll be prompted for input and the script creates everything you need, including failing unit tests. If you need help email the mailing lists.
Got Photoshop Skills? – Can you please make us a new logo? Pretty please?

Now go download those bits, run the reports, and see what you learn!

CGUG was at the first ever live Grails Podcast event during JavaOne 2009 in San Francisco, CA. This was the first time Sven Haiges and Glen Smith have ever broadcasted from the same location in front of a live audience. Panelists included Canoo Fellow Dierk König, Scott Davis, Andres Almiray, Danno Ferrin and James Williams. 

Scott Davis interviewed Dierk König, Canoo Fellow and Grails/Groovy-Evangelist for Thirsty Head at blip.tv. In the interview, Dierk gives an inside-view about new Grails improvements, about his JavaOne talk, JavaFX and the impact of Canoo Webtest. Enjoy this interesting chat about “beauty and code”!

This is just a quick note about the WJAX Java developer conference that take place last week in Munich.

The conference program was quite balanced and beside the main stream topics about SOA (ServiceOrientedArchitektur – represented by the SOACon conference), Spring, Application Security and OSGi there was a huge number of different topics, which were addressed by several talks.

Most interesting from my point of view were following sessions:

• Keynote from Jonas Jacobi: Re-architecting the Web with HTML 5 Communication.
• Talk from Karsten Lentzsch: Efficient design of swing UI’s.
• Talk from Angelika Langer: Java programming in the age of multicore.
• Talk from Dierk Koenig: RESTful JEE with Grails.

Canoo was exhibiting on a booth, which gave the great opportunity to present and talk about our products UltraLightClient (ULC), the just released language application for the IPhone (using canoo.net), our demo for the new JavaFX platform and fancy UltraLightClient / Swing rich client applications. In addition Canoo members used the presence to keep in touch with existing costumers, contact new ones or presented the company to potential new staff members.

Canoo Online Quiz

All the visitors on the booth and all other interested software developers had and still have the possibility to join an online quiz. Its possible to win an iPod touch or one of ten ‘Groovy in Action’ books. The quiz can be found at www.canoo.com/quiz and will end at the 30.11.2008.

Dierk König, Canoo fellow and author of the ‘Groovy in Action’ book, was holding a groovy workshop and was giving a talk about RESTful JEE with Grails.