Griffon is a framework for building rich desktop applications. It leverages the Groovy programming language and a number of the key features of Groovy including builders. It’s a fantastic effort and while it’s still fairly early days, the team is making great headway with the roadmap. The first episode of the GriffonCast is available for viewing and/or downloading. If you have any comments or would like to see specific topics covered drop me a note or post your thoughts on the Griffon mailing list.

The Keynote videos are also available at General Session Details and Video Replays

There are also a number of audio interviews available at Java One Radio Podcast

In the blink of an eye the 2009 edition of Java One is over. It was a good conference. Not the best Java One I’ve been to but still very much worth the trip down to San Francisco. The biggest unknown is what impact Oracle’s purchasing of Sun will have on Sun’s direction of Java. There is a ton of momentum in Sun and in the community that Oracle would do well to respect initially. Seeing Larry Ellision on stage speaking with Scott McNealy about investing in the platform is a very good thing. On this, only time will tell. As expected Java/FX featured prominently in many of the sessions. I think this technology has some potential if Sun (and Oracle) stick with it. Sun has a habit of taking things to almost complete and then letting it languish. In many cases the community picks up the loose ends and tries to add libraries, frameworks etc. but that is getting old. There is a lot of engineering resources being placed on Java/FX right now and it looks like it’s tracking pretty well. I’m cautiously optimistic that they can pull this off.

I continue to be very excited about the momentum behind Groovy and related projects (Grails and Griffon). If nothing else, I came away from this year’s Java One with a renewed sense of optimism about the direction of this language and the community behind it. I got to meet a few people that I’ve only ‘met’ through twitter from the Groovy and Griffon community and that’s great.

Areas I’ll be digging into further in the coming days/weeks/months

Teracotta’s Hibernate caching

JIRA

Hudson

Google Collections

Ribbon Component and the Substance Look and Feel

Griffon

Areas that I’ll be keeping my eye on

Java/FX, specifically components and layout managers.

Language Workbench from JetBrains

Here are a few stats:

3 Keynote presentations attended

15 Technical Sessions

7 Birds of a Feather Sessions

Visited with a ‘bunch’ of vendors including a great hour with the guys at Atlassian talking about Jira, Clover and Bamboo

Met up and visited with a number of aquaintences and friends that I’ve me over the years at Java One, Java Posse Roundup and now on Twitter.

Ken, Joe, Carl, Dick, Brendan, Pete, Stefan, Andres, Dave and Fred.

Java One for me is more about the community and the conversation than it is about the technical content.

In what has become an anual tradition, James Gosling hosted a two hour session in which he highlights some of his favorite things by the Java community. It’s a good show and well worth a watch. I was pretty happy to see Brendan Humpries of Atlassian get a Dukie award from James for his fine Clover product. Well deserved indeed. Other highlights for me included seeing a sneak preview of the Java/FX designer tool that Tor (and no doubt a cast of tens) have been working on for a while. The FIRST robotic competition was also very interesting as well. Nice to see an organization working to give kids access to building cool things and learning about engineering and programming disciplines in a fun environment. As well the work being done by Mifos in the realm of Micro Financing (like kiva.org) is very inspiring.

Getting Started with WidgetFX: Open-Source Widget Desktop Platform

WidgetFX is the widget desktop platform developed by Stephen Chin. I’m not 100 percent sure but I think Joshua Marinacci is involved with the project a bit. This widget platform was at least inspired from Josh’s AB5K/Glassitope swing based widget framework. It sounds like the Java/FX implementation makes this sort of thing easier to do than the Swing equivilant. Looks like an interesting project but to be honest I’m not a big user of Google gadgets/Apple’s Dashboard etc. I suppose if there was a bunch of cool widgets that would make my life easier then maybe I would be a bigger fan but it’s not one of those things that I’m that interested in. I do need to have a closer look at the Nabaztag rabbit he had wired up to a widget. Would make a great build monitor.

Defective Java Code: Mistakes That Matter

Bill Pugh, the creator of the findbugs project has presented at a number of Java Ones in previous years. He’s always entertaining and has a ton of great content. He’s currently on sabatical at Google and had a few observations about some patterns that he found. Find Bugs is one of those tools that I’ve looked at a few times but haven’t really done much with. It’s something I want to integrate into our incremental build process but there is the potential of sending the team off into bug fixing mode without any direction.

Bill had some good advice that would make this process easier I think.

• Start with new code. Changes will be fresh in the developers mind and the chance of introducing a side effect into working code is zero.
• As a team, identify the types of bugs you want to concentrate on. We wouldn’t be worried about SQL injection bugs for example but might be very interested in threading issues.
• One approach that worked at Google was after identifying the bugs you want to concentrate on, have a bug fixing day or two or three. Make it a fun experiment with the goal of keeping unit tests running and squishing as many bugs as the team can in a short period of time.

Just prior to Java One the Java/FX team released version 1.2 which includes some of the basic UI components that applications use. (Buttons, textfields, radio buttons, sliders etc.) This session went over the list of implemented components and introduced project Caspian which is the intial look and feel/theme/skin that these components can use out of the box. The session also went into a bit of detail of how some of the new layout managers are implemented. It’s still very early days and the team knows full well that the components they released just before Java One is not a comprehensive list (there is no table, combo boxes etc) and the layout managers implemented are pretty simplistic. There is so much work to do to round this implementation out it’s not funny but there appears to be a huge engineering effort behind this implementation so I echo that I’m cautiously optimistic about this. Sun appears to have their A-Team working on all aspects of this implementation including the designer tool which was previewed this week as well.

Breathe in JavaFX™ Technology

Of all the years I’ve been to Java One, I’ve never taken advantage of any of the Hands-on-Labs. To be honest in previous years there really hasn’t been that much that interested me. I decided this year to change that and sit through a Java/FX one. I figured 90 minutes of going through a tutorial would be a good use of time and if nothing else would give me a bit of expsoure to the language and implementation that up until this point has been mostly theoretical. This was a Bring your own laptop tutorial which required the installation of the latest NetBeans IDE preconfigured with version 1.1.1 of Java/FX. The presenter introduced the three different tutorials that were included, stepped folks through the first few steps and then let folks proceed at their own pace. There were a number of helpers available if participants needed a hand or couldn’t get something working.

The first tutorial was a photo viewer application that displayed a number of photos with buttons to navigate forwards and backwards through the photos. We added various kinds of transitions using Timelines with KeyFrames. The tutorial was really well done but like most tutorials the reasons why a particular implementation was chosen was not explained. It does provide a good set of examples though to dig further into. The NetBeans implementation of drag and drop coding with the Java/FX elements was interesting to see. Code completion needs a bit of work still and as I’ve mentioned I’m not a heavy NetBeans user so some of time was spent just trying to figure out how to do common things in the IDE.

I have the content from the tutorials so it will be something I have a look at in the coming weeks/months to continue getting some exposure to this fast moving addition to the Java platform.

Flamingo: Bringing the Ribbon Component to Swing

Of all the sessions I attended, I think I was most surprised by this one. Don’t get me wrong there was a ton of great content in a lot of the sessions but I guess for this one I didn’t really have any sort of expectations going into it and came away with a sense of ok, here is something I really need to look at.

The Ribbon Component was introduced by Microsoft in the latest version of Office after conducting a huge amount of User Interaction studies. It’s quite a huge change for Microsoft and there have been some negative reactions from users but they believe that this metaphor makes learning and using their products much easier. Kirill Grouchnikov, who is probably most known for his fabulous work with the Substance Look and Feel has been implementing a Swing incarnation of the Ribbon Component. He spent quite bit of time talking about the various elements of the ribbon component (tasks, bands, application menu button, taskbar panel etc.) and how they work together to convey meaning and more important context to the user as they are using the application. He pointed out a blog by Jensen Harris at Microsoft that details the evolution of their implementation. I haven’t had a chance to look at it yet but it sounded very interesting.

Additionally he showed an implementation of KeyTips which, when invoked, show shortcut keys to the components in the Ribbon control. It’s really well done and something that has been missing from the Desktop world for a while.

This one has the potential of changing our UI implementation substantially. It of course needs some careful thought and consideration but I like it and if we can perhaps add it as an adjunct to our current UI implementation that might be the best path forward.

This Is Not Your Father’s Von Neumann Machine; How Modern Architecture Impacts Your Java™ Apps

This session was done by was Cliff Click and Brian Goetz key guys in implementing the JVM. They spoke at break neck speed about the evolution of CPU and Memory architectures over the years and how developers need to be aware of how hardware implementation may impact their code from a performance and reliability point of view. A lot of the content was really only applicable if you’re writing your own compiler/VM but it’s still good to have an idea what is going on under the hood as it were. There was a reference to a paper that sounds interesting called What every programmer should know about memory.

JideFX: Bringing Desktop Richness to the Internet

David Qiao the CTO for JideSoft presented a few ideas about how they hope to bring their excellent set of Jide components to the JavaFX world. He didn’t really have much to show aside from a couple of examples that are very much works in progress. I’m sure it’s hard for component writers at the moment given the pace of development and missing bits with the Java/FX platform but in all honesty I don’t know why he presented anything. It’s much too early.

The Groovy and Grails BOF: With Live Grails Podcast Recording!

Sven Haiges and Glen Smith of the Grails Podcast hosted a panel with Scott Davis, Dierk König, Andres Almiray, James Williams and Danno Ferrin. They took questions from Sven and Glen as well as from the audience. It was very entertaining well worth a listen. I discovered Spock which is a fairly new unit testing framework that sounds very interesting and bears some closer investigation.

In this session, Amy Fowler, Jasper Potts, Paru Somasheka and David Grieve all from Sun took the Swing application that was written for last year’s installment of the GUI Makeover and added a bit of Java/FX. The idea is that there is a bit of a migration path for existing swing applications to Java/FX.

javafx.ext.swing.SwingComponent is the Java/FX component that can be used to wrap any existing swing component. The resultant object is a Node object that can be added to the FX scene graph. This is a decent approach but the biggest drawback is that none of the core elements for Java/FX (like transitions) can be applied to the contents of these kinds of nodes. They showed the CSS skinning approach that can be taken with Java/FX applications. It’s a good idea to separate the style (colour, font, size etc) from the actual components. Lastly Jasper showed an illustration of a an annimation on the Scene Graph.

It was pretty impressive all in all.

Move Your Users: Animation Principles for Great User Experiences

This session was presented by Chet Haas and Romain Guy. They introduced 12 animation principals that are documented in the book. The principals are related to traditional animation (cartoons) but they are very applicable to computer animation as well. They followed up a description of each of the principals with it’s application in building rich user interfaces on desktop applications. They did a great job. The content is something folks should consider when they’re implementing any sort of animation in their applications even things as simple as a fade transition or a scale. It’s really easy to get this stuff wrong and learning from the masters of animation who have been thinking about this stuff for almost a century could make a huge difference in your application.

The 12 principals are:

• Squash and Stretch
• Anticipation
• Staging (poses, camera angle, focus)
• Straight ahead vs. pose to pose (related to transitions)
• Follow through and overlapping action (objects should obey physical reality)
• Slow in and out (non linear timing)
• Arcs (things generally don’t move in a perfectly straight line)
• Secondary Action (an additional action that gives context to the main action)
• Timing
• Exaggeration
• Solid Drawing
• Appeal

One of the sources for their presentation was The Illusion of Life: Disney Animation

The Magic of the JXLayer Component

This session introduced the JXLayer component which is currently a java.net project. JXLayer is a wrapper or more precisely implements the decorator pattern for Swing Components. It has a bunch of different uses including a very lightweight way of disabling compound components, implementing mouse wheel scrolling as well a many other uses. We use this component in our framework quite a bit mostly in and around our UI security implementation. It’s great and if you write any Swing code and don’t know about this component go have a look. It was also announced in this session that this component is being promoted into JDK 7.

JavaFX™ Programming Language + Groovy = Beauty + Productivity

Dierk König author of Groovy in Action (still the best book on Groovy written to date in my opinion), presented a couple of different approaches to integrate groovy with Java/FX. One strategy is to use Java/FX for client code and then use a REST layer to have the Java/FX client talk to a back end written in Groovy (or Grails for that matter). This approach is pretty clean but you don’t get to take advantage of any Groovy code on the client.

Both Java/FX and Groovy are JVM languages and ultimately emit bytecode from their respective compilers. It is possible to reference Java/FX components from within Groovy but it’s messy. Andres Almiray has a JavaFX builder in the Griffon Project that begins to make this integration easier but it’s still early days.

The short answer is that true integration at this point in time is hard and will get better as Java/FX matures.

Hudson Community Meet-Up

I’ve been looking into Hudson for a few months now and it just keeps getting better and better. The project lead (Kohsuke Kawaguchi) gave a bit of background and some of the current trends of Hudson. The growth of the product and the community surrounding it since last Java One is very impressive. Plugins for Hudson are one of the distinguishing features. Tom Huybrechts from AGFA Healthcare demoed a new plugin he wrote that implements the JBoss Rules Engine (drools) within Hudson. Layered on top of it is a graphical builder for building workflow steps, gathering input at various points in the workflow and a ton of other cool stuff. It was very impressive and something I want to take a closer look at.

Netbeans project integration was also demoed (actually talked about as there was a technical glitch with the netbeans machine/projector combo). It would be interesting to monitor builds from within Netbeans, kick them off etc. but given that we’re an IntelliJ shop it’s not that relevant. There may be some form of plugin for IntelliJ but the web interface is great so I’m not sure we would even look at it.

Griffon in Depth

Danno Ferrin and James Williams gave an introduction to Griffon which is a Grails inspired framework for building Swing applications in Groovy. It’s still very early days with the project however the project team has leveraged all of the great work from the Grails project in bootstrapping the Griffon project. This is one technology that I’m quite excited about. Writing swing apps in Groovy is possible (see this post for an example) however writing a big Swing app would be quite a lot of work. The idea behind Griffon is to put a framework in place to support building Swing applications with the same sort of velocity the web guys are seeing with frameworks like Grails and Ruby on Rails. The fellows demoed a few applications written in Griffon the most impressive one was Greet which is a Twitter client written in Griffon. I wish the fellows much luck with this project and I’m trying to figure out a way I can help in some small way. Swing and Groovy in the same stack makes me very happy

• Pretty typical of previous years. Billions of devices, millions of developers blah blah blah.
• Java Store introduced. Strikes me a bit of me too wrt to the Apple App Store. No relevance for Entero.
• Scott McNally and Larry Ellison talk about the future of the platform (with all sorts of caveats about future looking statements). Said most of the right things. Look to keep investment up in R&D plus continue with Java/FX. Cautiously optimistic here.
• Lots of partner demos, nothing too exciting.

Deploying Java™ Technology to The Masses: How Sun Deploys The JavaFX™ Runtime

Good first session. Interesting to see that Sun has the same sort of problems as everyone else wrt deploying content to the desktop. There were a few good practical tips that I’ll want to dig into.

• Pack200
• JNLP additional tags.

Extreme Swing Debugging: The Fast and the Furious

This was an introduction to the java.net Swing Explorer project. This is a project that I’m familiar with but it was good to see the EDT violations feature as well as using the “Player” feature to find painting issues. It’s a great tool to have in your swing debugging arsenal.

Tuesday Afternoon Technical General Session

• Roadmap for JDK 7
• Modularity
• Project Coin (small language changes)
• EE 6

Extending Java™ Technology and Developing DSLs with the JetBrains MPS Open-Source Language Workbench

This was an interesting session for sure. The folks at JetBrains have a tool
they call Meta Programming System Workbench that is used for designing and working with domain specific languages. It built on the core IntelliJ platform and has a lot of really great features. I was thinking we could use it for embedding in our application for our users to build scripts initially. Longer term I’m thinking that implementing our formula pricing model in a DSL is the way to go but am still not sure about that. Regardless, this may be a tool that might make that easier.

• Development environment for building domain specific languages
• Handles compiling and parsing
• Works directly on the AST

An Introduction to Complex Event Processing on the Java™ Platform

This is an area I know nothing about. Complex Event Processing deals with the query and visualization of huge data volumes. Real time systems for things like stock trades or perhaps data that comes from SCADA systems. There is a branch of Computer research that deals with this sort of volume. There is a query language called CQL that is like SQL but has a temporal component to the query language. It also has specific constructs for filtering and aggregation of massive datasets. This content was presented by Oracle/BEA where they touched on their product.

Toward a Renaissance VM

This was a fascinating session by John Rose and Brian Geotz of Sun. They dove into some of the very nasty problems that modern compiler writers are grappling with. The JVM hosts a number of languages and has for quite some time. JSR-292 (Supporting Dynamically Typed Languages on the Java Platform) is the JSR under which this work is being done. I left this session feeling very humbled and grateful that there are some very smart guys working on new VM extensions that are going to make my life easier in the future.

Creating Java™ Technology-Based Applications for Mac OS X: Is It Cocoa or Is It Java Technology?

I love my Mac but am a little frustrated with Apple in the pace that they implement the JVM on OS/X. They are on 1.6 finally but Apple took a long time to get there. Regardless, there are a bunch of folks in the Java community that have stepped in to help making Java Swing apps on OS/X easier. In this session, Deane Richan from the Xito project spoke about a number of strategies for improving the integration of a Java Swing application on OS/X such that the swing app looks closer to a native OS/X application. Good session and a project I want to take a closer look at.

The Collections Connection (Gala Tenth Edition)

Josh Bloch, the creator of the Java collections library has been doing this Birds of a Feather Session for about 12 years (I think he missed a couple along the way which is why this is the tenth one). I’ve been to a bunch of them and always come away learning something new. Josh left Sun to work at Goggle a couple years ago. He is still very active in the Java community and continues to make huge contributions to the platform. This year he brought along a couple of his colleagues from Google; Martin Buchholz and Kevin Bourrillion. They spoke of a few things that might be coming in JDK7 but more interesting (from my point of view) is they also touched on the Google Collections package which adds a number of ‘missing’ collection implementations. It’s something I’ve wanted to take a look at for a while and even more so after hearing about some of the implementations in this framework.

Meet the Java Posse

Of course I’m going to pop in and see the guys do their third annual Podcast from Java One. It was a packed room and the fellows didn’t disappoint.

I’m down here with a couple of fellows from work, Glen and Shawn. It’s the first time I’ve had any one from Entero down here with me so that’s pretty cool. There is always way to much to see so perhaps with the three of us, we’ll get a chance to cover more content.

We registered (a process that Sun and the conference organizers have pretty much nailed), picked up our conference materials and walked around getting the lay of the land. When the vendor pavilion floor opened, we wandered around there for a bit, picked up a few T-Shirts and bumped into Glen.

The thing I noticed walking around the show floor was the number of larger companies missing that were there in previous years. Oracle had a huge presence last year, this year nothing (probably related to the merger). IBM is not here (sour grapes re:merger ?), Google, not here. There is some alternate universe thing going on as Microsoft is here with a pretty large presence. It’s a bit odd compared to previous years.

Ice Soft

The fellows from Ice Soft are here. My friend Ken is one of the dev leads so it’s always good to catch up with them. He did a demo of some of the new gear they have on the go for their IceFaces product. They stuff they do is pretty cool however it’s all web/ajax/Java Server Faces which is a technology stack we don’t dabble in.

Terracotta

Shawn and I also had a great discussion with a couple of developers from Terracotta. We need to do some serious R&D into a second level cache for our domain layer and Terracotta is probably the way we’re going to go. They are implementing their own hibernate caching strategy within their clustering technology. It has some monitoring and configuration tools that look pretty impressive. Shawn put his name in for the beta program so we’ll take some time in the coming weeks to put Terracotta through it’s paces.

Atlassian

The other company I want to spend some time with is Atlassian. We use a bunch of their products including Crucible, FishEye and Confluence. Pete and Brendan (two fellows I’ve met at the Java Posse Roundup) have pretty senior development/management positions at Atlassian but they were over at the Atlassian summit. I’ll hopefully get a chance to meet up with them later in the week and catch up.

First Impressions

I’m of a bit of mixed mind about Java One this year. On the one hand, it’s great to be in San Francisco, getting a chance to hang out with folks that I’ve come to know over the years. There is always a cool vibe around the conference. It is different though. There does seem to be a certain pall though. Major change is afoot and it seems like there is a lot of uncertainty about the future. I am looking forward to the week though.

Java FX

I’m sure this year will be all about the Desktop (again) with Java FX. I’m mildly interested to see what all the hype is about. I’ve been a Swing guy for most of my Java life and while I am excited about seeing some of the new shiny tools and techniques (Scene Graph being very high up there), part of me is sad to see so much engineering time and resources being focused on this. Amy Fowler is doing a session entitled Extreme GUI Makeover (Hybrid Swing and JavaFX™ Technology) which promises to be a Pimp my Swing App with Java/FX.

Groovy

I first learned about Groovy at Java One in 2004 where James Strachan gave an introduction and overview of the language. This was the first time I had considered using anything else except for Java on the JVM and I remember having one of those ‘light bulb’ moments in the session. It’s totally changed the way I think about the JVM and languages in general. We’re a pretty heavy user of groovy in our application and I’m quite excited to see a number of Groovy sessions at Java One this year.

Some of the sessions that have caught my eye are:
What’s New in Groovy 1.6? with Guillaume Laforge
Griffon in Depth with Danno Ferrin and James Williams
“Design Patterns” for Dynamic Languages on the JVM™ Machine with Neal Ford
The Groovy and Grails BOF: With Live Grails Podcast Recording! with Sven Haiges and Glen Smith of The Grails Podcast

Java EE

Not nearly as sexy as Java/FX, the Java EE space will probably see some new announcements and updates on some of the key JSRs. I haven’t really been following the progress of the JCP that closely and can usually get all I need to satisfy my curiosity at Java One.

Summary

I’m really looking forward to it. San Francisco is one of my favorite cities and having been there a few times I’m starting to have a few favorite haunts including a new one I found last year. If you’re going to Java One this year, drop me a note on Twitter.

If you would rather not hear me blather on describing this code, you can see a quick 20 second demo of the running application here.

I decided to write a little groovy app that displayed a few participants from the roundup and their origin airports on a Google map. I wanted to illustrate a few common Groovy idioms and illustrate how easy it is to create a pretty functional app in just a few lines of code.

The first thing of note in the script is a small class that represents an Attendee. Notice there is no constructor, no getters or setters. The only method in the class is the toString method. This method isn’t actually called in the script but I wanted to illustrate what a simple Groovy String (GString) looks like. The method has an implicit return (as the string is the last statement in the method). The String has references to the properties in the class. These properties are enclosed by ${}.

8
9
10
11
12
13
14
15

class Attendee {
  String name
  String lastName
  String email
  String origin
 
  public String toString() {"Name:${name} Last name:${lastName} eMail:${email} origin:${origin}"}
}

The next few lines of code construct new instances of our Attendee class, one for each attendee. Normally these would come from some sort of datasource like a database or something but to keep this example simple, they are just hardcoded here. There are a few things of interest in this code. The first thing to note is that the attendees variable is dynamically typed. It is constructed using an ArrayList that is typed. This is really just to illustrate that Groovy does support Java generics. A typical declaration of a list in groovy would be def attendees = [] the [] are shorthand for new empty ArrayList().



The next interesting feature is the << construct. This is the equivalent of attendees.add().



The last thing to note in this example is the way we’re constructing the Attendee class. We have a comma separated list of values that are prefixed by property names. Notice that in our class definition we don’t have a constructor. This is one of the nice features of Groovy, named parameters.

17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

def attendees = new ArrayList<Attendee>()
 
attendees << new Attendee(name: "Peter", lastName: "Pilgrim", email: "pp@example.com", origin: "IAD")
attendees << new Attendee(name: "Joel", lastName: "Neely", email: "jn@example.com", origin: "MEM")
attendees << new Attendee(name: "Dianne", lastName: "Marsh", email: "dm@example.com", origin: "DTW")
attendees << new Attendee(name: "Carl", lastName: "Quinn", email: "cq@example.com", origin: "SJC")
attendees << new Attendee(name: "Dick", lastName: "Wall", email: "dw@example.com", origin: "SJC")
attendees << new Attendee(name: "Joe", lastName: "Nuxoll", email: "jn@example.com", origin: "SJC")
attendees << new Attendee(name: "Bill", lastName: "Pugh", email: "pp@example.com", origin: "SJC")
attendees << new Attendee(name: "Dave", lastName: "Briccetti", email: "db@example.com", origin: "SFO")
attendees << new Attendee(name: "Todd", lastName: "Costella", email: "tc@example.com", origin: "YYC")
attendees << new Attendee(name: "Ståle", lastName: "Undheim", email: "su@example.com", origin: "FRA")
attendees << new Attendee(name: "Eirik", lastName: "Bjørsnøs", email: "eb@example.com", origin: "MUC")
attendees << new Attendee(name: "Andrew", lastName: "Harmel-Law", email: "al@example.com", origin: "EDI")
attendees << new Attendee(name: "Oliver", lastName: "Gierke", email: "og@example.com", origin: "ORD")
attendees << new Attendee(name: "Joe", lastName: "Sondow", email: "js@example.com", origin: "LGA")
attendees << new Attendee(name: "Fred", lastName: "Simon", email: "fs@example.com", origin: "ORD")
attendees << new Attendee(name: "Daniel", lastName: "Watson", email: "dw@example.com", origin: "ATL")

The next section is an implementation of a SwingBuilder. Builders are a pretty common idiom in Groovy. There are MarkupBuilders, AntBuilders and others including a SwingBuilder. The SwingBuilder abstracts a lot of the nasty complex requirements for building a rich user interface in Java. Swing is the desktop UI library. It’s very powerful but can also be very complex to use. The SwingBuilder provides a very elegant abstraction on what turns out to be a complex model. One of the great things about the SwingBuilder (and all Builders for that matter) is that in just reading the code, it’s quite apparent what the user interface is going to look like. We start with a Frame. Within the Frame we have a panel and within the panel we have a button and a label. We have a second panel that contains a table and thrid panel that contains the Google Map wiget. The equivalent swing code to implement this would be many more lines of code probably two or three times the amount of code I would guess. The other thing is that it would be harder to visualize the layout of the application with standard swing code. With the builder implementation, we can see how the components are nested within each other.



I’ll talk about the {…} code behind the Refresh Button and the table in a second. Before we leave this code I wanted to talk a bit about the Map component. The Google Map component is based on some fine work by Josh Marinacci that can be found at java.net JXMapViewer.The interesting thing with respect to this example is that any Swing component can be wrapped by a widget call in the builder. This provides a very nice mechanism for reusing existing swing classes within the builder pattern.

38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

def swing = SwingBuilder.build {
  frame(title: "Java Posse Roundup 2009", pack: true, show: true, defaultCloseOperation: EXIT_ON_CLOSE, id: "frame") {
    borderLayout()
    panel(constraints: NORTH) {
      boxLayout()
      button(text: "Refresh", actionPerformed: {
        doOutside {...}
      })
      label(id:"status")
    }
    panel(constraints: CENTER) {
      borderLayout()
      table() {...}
    }
    panel(constraints: SOUTH) {
      borderLayout()
      scrollPane() {
        widget(new JXMapKit(), defaultProvider: JXMapKit.DefaultProviders.OpenStreetMaps, dataProviderCreditShown: true, id: "map")
      }
    }
 
  }
}

Aside from the structure of our application, the most interesting code in the builder can be found in the actionPerformed closure. This closure will be called when the Refresh button is clicked. There is quite a bit going on in a very few lines of code. The first thing of note is the doOutside method that takes a closure. Quite simply the code in the closure will get executed in a separate thread. How cool is that? Within the closure we iterate over the attendees collection. For each entry in the collection we make a call to the Yahoo Geo Service. Many thanks to my friend Ido Green for introducing me to YQL via his lightning talk. The XmlSlurper class is a handy means for parsing XML content. The query we’re composing takes the origin airport {it.origin} and returns an xml document that contains a bunch of geographical information for the airport. In our case, we’re only interested in the latitude and logitude. We pull those values out of the resulting document and then construct a WayPoint. The WayPoint object is present in the JXMapViewer package and is relly the only thing we need to construct a pin point on the map.

43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

      button(text: "Refresh", actionPerformed: {
        doOutside {
          def waypoints = new HashSet<Waypoint>()
          attendees.each() {
            def url = "http://query.yahooapis.com/v1/public/yql?q=select%20*%20from%20geo.places%20where%20text%3D%22${it.origin}%22&format=xml"
            status.text = "Looking up Airport: ${it.origin}"
            def doc = new XmlSlurper().parse(url)
            if (doc.results) {
              def latitude = doc.results.place[0].centroid.latitude.toString()
              def longitude = doc.results.place[0].centroid.longitude.toString()
              waypoints << new Waypoint(Double.valueOf(latitude), Double.valueOf(longitude))
            }
          }
          WaypointPainter painter = new WaypointPainter();
          painter.setWaypoints(waypoints);
          map.getMainMap().setOverlayPainter(painter);
          status.text =""
        }
      })

The last thing of note is the table entry. The table has a tablemodel which is constructed using the list of attendees. The model itself is very simple and consists of a propertyColumn that has a constructor that takes the column title and the name of the property to display. If you’ve attempted to implement a tablemodel in java (even a read only one like this one), I’m sure you can appreciate the brevity and cleanliness of this implementation.

67
68
69
70
71
72
73

      table() {
          tableModel(list: attendees) {
            propertyColumn(header: 'Name', propertyName: 'name')
            propertyColumn(header: 'Last Name', propertyName: 'lastName')
            propertyColumn(header: 'EMail', propertyName: 'email')
            propertyColumn(header: 'Origin', propertyName: 'origin')
          }

That’s it. 87 lines of Groovy goodness that renders a Google Map in a swing app, utilizes YQL to resolve geo location information for airports.

The source and external libraries that are required to run this application are available here. You’ll need Groovy installed. This archive has idea project files included. If you use eclipse or netbeans you’ll have to add the three external libraries to your project manually.

jpr09.zip