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