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

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.

first of all, it is very helpful to familiarize yourself with your OS-specific keyboard commands for moving the cursor around and with the Shift key pressed, doing a selection. On Mac that is Cmd left/right for begin/end of line and Alt left/right for jumping over words. Of course you can use the mouse for selections but once you master the keystrokes, you will be faster and more precise.

is widening the current selection. That is, if you already have a selection, it expands it to the next enclosing syntactical scope (expression, statement, block). Without a selection, it starts a selection at the caret.

Mac users may expect Cmd W to close the current editor (internal window) as typical for mac applications, but that functionality is mapped to Cmd F4 in the standard keymap (somehow resembles the Windows keystroke).

I use widening most of the time to select a small expression precisely – often for later use in a refactoring. I start in the middle of the code and hit Cmd W repeatedly.

When selecting a larger block, let’s say a method or a whole class body, it’s efficient to place the cursor just after the opening brace and hit Cmd W just once to select the whole block.

surrounds the selection (or current line if there is no selection) with a live template. This features spares you the need for fiddling around with cursor positioning to put some code into an “if” block and the likes. I even made my own templates for surrounding a selection with parentheses, brackets (to make a literal Groovy list), braces (to make a closure or block), single quotes, and double quotes.

Especially putting quotes around a selection is nice since otherwise IDEA sometimes inserts pairs of quotes when it shouldn’t.

when you have a selection and open the context menu (right mouse click) you’ll see a “Compare with clipboard” entry, which opens the internal diffing view. Nice.

yanks out the current line. I use this a lot. It is quicker than selecting and deleting even when yanking many lines, since you can simply press the same keystroke again (remember the discussion about interaction design?).

duplicate the current line (or selection). Again, a much used shortcut for me for making variants of the current line or selection. Some Eclipse converts take issue with this one since they expect a delete action. (It’s worse when you get from IDEA to Eclipse and mistakingly delete a line that you want to duplicate, but then you deserve the pain)

comments the current line or selection with a line comment (//). This has a little gotcha when working with non-english keyboards where you need to press Shift to get to the slash character. With my swiss-german layout the shortcut is actually Cmd . (dot) because the dot is where the slash is on english keyboards (see also http://youtrack.jetbrains.net/issue/IDEA-63779).

join the current line with next line. This shortcut is used by many text-editors. It is worth remembering. Much faster than a manual join.

moves the current line (or selection) one line up or down. This used to have issues in older versions when it tried to be too clever about which lines to jump over, e.g. when you select a whole method, it jumps not per-line but per-method. This makes sense for methods but other blocks are not as easy to support since you may want to nest them. The “intelligent” jumping sometimes led to unexpected results, especially in Groovy code. I haven’t seen any trouble with version X, yet.

the “insert explaining variable” refactoring is something you normally call on a selected expression but when there is no selection, it takes the current line as the expression. Now, this has an interesting effect: in a variable assignment, you never have to write the left-hand side! I learned this from IDEA uber-guru Vaclav Pech himself. It works like this: you don’t type “MyType myRef = expression” but only “expression” then strike Cmd Alt V. Try this and enjoy the effect.

helpful selection modes and type inference

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

With only a few keystrokes it becomes much easier to move code around in your editor or gather more information.

Press the Alt key while selecting with the mouse

and the selection is in “column” mode. Very useful for many well-formatted source files and often even more in resource files with tabular format.

Column mode

can also be toggled with a keystroke. I couldn’t quite remember the default keystroke, so I’ve set it to Cmd Alt Backspace. To find your keystroke look in the Edit menu under Column Mode (or as always use Cmd Shift A and type “col”).

Hold Cmd while hovering over a reference

and you will see the inferred type like so:

Note that this is Groovy code and from the content of the dynamically typed myMap, IDEA infers that this is a Map from Strings to Integers, i.e. not only the raw type is inferred but also the generic type! Is that cool or is that cool?

We touch a very important topic here.

Many developers are under the misconception that IDEs can only do what the compiler of a specific language does. The Groovy compiler does no type inference but still, IDEA does and uses this info for code completion, analysis, refactorings, warnings on mistyped method names, and so on.

This shouldn’t come as a big surprise. Even for Java, IDEs do a lot more analysis than what the Java compiler does.

Using a dynamic language like Groovy does not mean that you lose all the IDE support (as you can hear occasionally). Also note that in Groovy you can always declare your types, making it an optionally typed language.
Inside IDEA, you can seamlessly switch between Groovy and Java, using cross-language testing, debugging, analysis tools, and refactoring.

The next post will be about more editing commands.

keep groovin’
Dierk
@mittie

Understanding dependencies – a smooth intro

Beside all the navigation, editing, and refactoring goodness that IDEA brings to the table, there is one feature that I really adore and find under-utilized by most teams: the dependency structure matrix (DSM).

It seems that many developers shy away because they expect it to be difficult, while in fact it is easy to understand and remember with just a little bit of intro. Here it comes.

Prerequisites: your project must compile. That’s it.

How to start: from the Analyze menu choose Analyze Dependency Matrix.

This is what you see (this is the code from my personal wiki – yes, it has only 5 classes. The code is under github.com/Dierk/MittieWiki)

Now, what does this mean? Well, it actually shows the layering of your architecture – not how you want it to be but how it actually is.

How would you depict the architectural layers in a document? Probably as some kind of pyramid with the common functionality as the fundamental bottom layers and users of the infrastructure on top of it. The DSM is exactly that!

If you want, you can imagine the pyramid being slightly pushed to the left such that the left edges align. Then you have exactly the lower-left triangle of the DSM. The upper layers depend on what is below them. They use the common base functionality.
The common base layers use nothing, therefore they go to the bottom. The uppermost layers are used by nobody.

For the moment, we don’t look at the numbers since we only seek to understand the structure.

The structure of the DSM shows that EventController (second line) uses classes below it. But which ones? Simply click on the EventController label and you will see this picture:

Every class that EventController actually uses gets an orange marker. Do yo see the one at CookService? From that we can tell that EventController uses CookService and no other project class!

CookService seems to be an interesting class. So let’s click on its label:

Do you see the green markers? They tell that CookService is used by EventController, FindController, and PageController.

From this intro you can infer that green markers should always be above the current selection and orange ones below.

Understanding the numbers

The numbers quite obviously show how often a class uses some other class. But which cell contains this information? Well, if you think about it, there is only one possible way of arranging numbers in cells that makes sense. Let’s revisit

The blue cross covers the number 5 saying that EventController uses CookService 5 times.

I mean, you only use classes below yourself, that means a cell that tells how often you use it must necessarily be placed below you, right? And where else should it be than in the row of the used class? And it is quite obviously in the column that responds to the using class.
The columns are not labeled explicitely but they are in same sequence as the rows and therefore you can simply use the diagonal as a “mirror”.

Fazit: usages along with usage counts are shown in the column below the diagonal!

With this knowledge we can anticipate what happens when we select the other controller classes. They equally show 5 usages of CookService.

Now, think in the opposite direction. Who uses our class?

EventController uses CookService 5 times. In other words: CookService is used by EventController 5 times. And the same is true for FindController and PageController. That’s three times the used-by count of 5 in the same row. This means: used-by along with its counts is shown in the row of the used class!

In cases where the situation is less obvious, you can select a single cell (here where the 5 is in) to see the whole picture:

So much for the intro.

A very comprehensive description with many use cases and screencasts is under http://www.jetbrains.com/idea/features/dependency_analysis.html . You will see that this intro helps you understanding it. Once you have understood the concept, you will easily grasp package dependencies, module dependencies, and cyclic references.

The DSM has become an indispensable tool for my consulting work. Whenever I visit a new project, it is my first tool to fire up. There is so much to tell from this simple matrix.

After a while, you start to see patterns like a horizontal line of dependencies (as in CookService) to show a service or utility class or a line just below the diagonal to show a strict layering, breaches of layering, and so on.

A word of caution

Static analysis never shows the whole truth. Especially, it doesn’t show semantic dependencies. Just recently I heard a friend advocating the use of dependency injection to avoid unwanted dependencies in the DSM. It is very easy to fool oneself with that approach if the semantic dependency is not resolved at the same time.
Actually, I’d rather like to see my unwanted dependencies in the DSM than hiding it with tricks (DI, AOP, “Object” in signatures, “def” in Groovy).

I hope this little intro motivated you to give the DSM a try.

keep groovin’
Dierk
@mittie
dzone: http://www.dzone.com/links/r/intellij_idea_tips.html

Caution: this post contains philosophical content!
(at least some readers call it so when I reflect on what makes software great)

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)

Let’s start with a simple example.

Cmd Shift A

pops up a simple text field (and one checkbox) where you can select from all available actions in case you have forgotten the shortcut or its place in the menu tree. It appears like the picture below if you e.g. look for the dependency analysis features by entering “Dep”

• First of all, this feature is immensely useful for itself. Especially, it is much quicker than scanning through the menus or reading through the help pages. Apple, Microsoft, could you please steal the idea for your software products?
• Second, note how slick the search “dialog” is. You hardly recognize it as a dialog at all. Many other software products pester their users with ridiculously overloaden search dialogs. JetBrains learned from Google’s success: one entry field is enough.
  Providing many options to the user is actually the easy way. Taking the hard decisions of what not to show is the true mastery of interaction design.
• Finally, the way that you narrow down the options is consistent throughout the whole application. Here is another example: use

Cmd , (comma)

to open the setting dialog. Now let’s assume that you want to enable the (very useful) feature to highlight all usages of the symbol that contains the text cursor (also known as “caret”). There are so many possible settings. How do I find the respective checkbox? Just start typing in the search field and the settings view narrows down the options and highlights the candidates.
Try entering “highl” and you will see in the Editor section the checkbox “Highlight usages of element at caret“.

The consistent availability of interaction concepts is key to a usability.

Here are some more of those consistent features. When used in differenct contexts, they may technically do totally different things but still serving a very similar user goal.

F2 (Shift F2 for backwards)

jumps to the next error but also to the next inspection warning, i.e. the next point that requires your attention.

F3 (Shift F3 for backwards)

jumps to the next Find target (when you called the in-file finder with Cmd F) but also to the next usage of a symbol (when you used the “find all usages of symbol under caret” feature with Cmd Shift F7).

F4

from many different tools opens the selection in the editor and gives it the focus

F5

copy of classes or files, even Shift F5 for the “clone” refactoring.

F6

move pretty much any OO construct anywhere. Shift F6 for the “rename” refactoring.

The point is that these actions are technically quite different in the different contexts but serve a similar purpose and so using the same shortcut is a consistent choice – easy to explain, easy to remember.

So much for today. It was a bit more contemplative than usual. However, I hope I could inspire you to recognize more of the interaction design of the applications that you use – and maybe even to pay more attention to the interaction design of the applications you build.

The next post will again be about hands-on tips.
Dierk Koenig
@mittie

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.