I was both happy and sad that this would be the final day: Happy because I would actually get a chance to digest some of what had already been thrown at me thus far, but sad because there was so much more I knew I could learn from some of the guys giving these talks. All of them were incredibly smart and really knew their stuff...it's hard not to want to be around these kinds of people.
First up on my list were the two consecutive sessions on the Google Web Toolkit (GWT). The sessions were headed up by David Geary, who had given the JSF talk I sat in on the previous day.
Well...after sitting in on these two sessions, I can say with certainty that I was completely sold on the Google Web Toolkit.
Asynchronous calls are handled pretty easily, and they seem to map really well to the Java language in the way that the GWT offers. It's pretty easy to set up a call, and provide a listener for the response.
I think web developers working in Java already can benefit the most from this toolkit, especially if they are looking to inject some kind of AJAX-style features in their web applications. Being able to keep all (or most) of your code on both the server and client as Java, and still be able to leverage AJAX is a huge benefit to a project. This is obviously where the GWT is targeted, but I got the impression from a lot of people sitting in on these sessions that they weren't really expecting GWT to be as full-features and powerful as it is, which makes me think that it's a seriously misunderstood technology.
Google should be doing a better job promoting the GWT, as I think it's a pretty significant leap in AJAX development for Java developers.
I was extremely impressed with the GWT following the these two sessions David Geary.
For the next talk, I decided to sit in on another Groovy session. This time, it was Jeff Brown giving a talk on Groovy's metaprogramming capabilities. Jeff had sat in on the Birds of a Feather session at the end of the previous day's festivities, and after hearing what he had to say there I thought it would be worth it to hear more of his thoughts about Groovy.
Scott Davis had covered some of Groovy's metaprogramming capabilities back on the first day of the conference, so I had a basic understanding of some of what Groovy could do in this regard. Jeff, however, when into significantly more detail in how to work with Groovy's metaprogramming features, and provided a great number of examples on how these capabilities could be leveraged in a real project.
Starting with the Expando class, Jeff went on to cover things like Closure delegates, and the ExpandoMetaClass, which is used to dynamically add behavior to the existing core Java classes.
Jeff also covered the implementation of builders for various uses -- a builder to easily construct XML based on Groovy code, for example.
One example he showed that resonated with me was the SwingBuilder. This builder class made constructing GUI widgets in Swing significantly easier, and has made me consider adopting this for my current project (provided I can make a good case for it...and maybe get a proof of concept going). Working with SwingBuilder appeared to be significantly easier than anything I've seen anyone try to implement, and I'm all for making my code simpler. Groovy really shines at this, for sure.
Jeff also covered ways that the dynamic method dispatch in Groovy can be leveraged to make more meaningful queries to a database. For example, by being able to call methods like
.findByKey("foo")directly on a class when those methods don't actually exist until runtime, and are dynamically generated based on the name of the method itself. There is some really powerful concepts here that can make a lot of Java projects easier to work with, and this is really where I started to see Groovy's capabilities shine.
Between this talk and the two previous ones, I've been pretty well convinced that Groovy has a lot of potential, and I look forward to trying out some of these features for myself.
For the final session of the day, I attended another talk by Ken Sipe. This time he talked about Hacking...as in the breaking-into-phishing-scamming-doing-bad-things kind.
Once again this was more of a overview, and sadly there were some technical difficulties during this talk that prevented Ken from really being able to demonstrate some of the things that he was talking about (seems the internet connection for the conference was cut off prematurely). Nevertheless, it was a fun and informative talk, and what things Ken could show us were fascinating.
Ken gave lots of good bits of information during this talk. And while I'm not going to iterate everything he was talking about here, for obvious reasons (if you're smart you can probably figure them out yourself), one thing I took away from this talk was this:
We're all incredibly naive about security.
I think I finally understand why Bruce Schneier changed his point-of-view about security from that of a purely technological solution, to that of a psychological/sociological problem that cannot be easily fixed. Far too many people out there either just don't understand, refuse to acknowledge, or are overconfident in their security measures when it comes to software development. And there is definitely not enough critical analysis going on that there really should be.
And with the end of this last session came the end of my time at the conference. I had a blast attending all of these talks, and learned so much in such a short time that I'm going to be spending months evaluation all of the options that have been opened up before me. I'm amazed at home much I picked up here, and I'm looking forward to attending this again next year.
Hell...I may actually try to pay my own way if I have to...