Last weekend I went to the Greater Toronto Software Symposium, part of the No Fluff, Just Stuff tour. It is the first time that they hit Toronto and just to go straight to the point I think it will be a huge success in the years to come. Here are my impressions and my feedback about it.
I wasn’t able to attend on Friday afternoon, I was too busy at work, but for the joy of my wife I went to Saturday’ and Sunday’ sessions. Yes, because it mainly takes place during the weekend, which makes it different from any other conference/workshop/event I’ve been in my precedent life. This is a plus, definitely, maybe not from a family perspective, but for sure for your employer. And it’s about motivation as well: you better get something back on it, otherwise why should you waste some time that you could pass in a better way with your kids?
Saturday morning there was not anything too cool to start, so I’ve decided to go to Applied AOP by Brian Sletten. My spirit was kind like this: yeah, Aspect Programming, I know this stuff, logging and auditing, I’ve never felt the need to really use it in practice. Oh boy, I was wrong, so wrong! Maybe it’s because I’ve done only some superficial experiment in the past, when tools where not mature, but in this session Brian Sletten was able to show a couple of neat tricks that I’ve loved. For example, using AOP to do some sort of dynamic code analysis. Or using AOP to force objects from a 3rd party library (e.g.: the jdk) to throw an exception under certain conditions, which provide a better testing scheme rather than some convoluted mock structures. Last but not least, a very clean smart proxy implementation for RMI objects resilient to failures. The maturity of the Eclipse plugin has impressed me as well. Of course, if you deal with languages like ruby you don’t really feel the need to use AOP, unless you are fanatic about it, but I can definitely see some applications in everyday java jobs.
My work in these days is almost entirely on server side stuff, so I went to David Geary’s session about The Google Web Toolkit to see something different. Another good session, definitely. GWT has its own maturity problems, but I’ve really appreciated the component approach to web development that piggybacks on AWT and Swing. It’s amazingly simple, especially if you want to integrate things like scriptacolous or prototype. Of course, relying on a different browser for development purposes (the so-called Google browser) has its own limitations and poses some risks, but being able to debug your components in a live page is definitely a plus. A distinctive characteristic is the ability to treat asynchronous calls to the server with an event model that resembles event-handling in AWT. Good stuff and good work made by David.
After lunch I went to Agile Metrics and Diagnostics: Knowing When and What to Measure by Deborah Hartmann. This is the only agile session that I’ve attended, even though I may say that agile topics were hot and there were many sessions that seem reasonably good, but rather basic to me. I’ve decided to attend this one mainly to know Deborah better, given the fact that we have exchanged just a few emails in the past. There were some organization glitches, but Deborah was able to overcome them. And the session was pretty good, which is particularly important if you think how much I do care about metrics in agile processes. I’ve particularly liked the idea of categorizing in metrics (measurements of direct contribution to an organization’s bottom line) and diagnostics (measurements of how we produce, to use for continuous improvement). In the agile community we focus too often to the latter, forgetting that it’s the former that gives us more accountability and it establishes a better way to deal with the management and the customer side.
Last session of the day was Understanding the Role of an ESB by Mark Richards. It was an interesting overview of the overhyped topic of ESBs, treated in a very pragmatic way. The problem is that the speaker spent probably too much time coding pieces of an ESB architecture live in front of us and it has devoted not enough time to other topics that may have been helpful. I understand his goal: showing us how simple it is, beyond hype and buzzwords. It’s a very honourable goal, but next time he should include some slides with already made code and show it instead of typing it in front of us.
First Sunday’ session was a very bad call: I’ve decided to go to a Spring session, but I have to be honest, I escaped from it very soon. I was very curious and animated by positive thoughts; in the end, I’ve always read about Spring, but never used it in real life. I don’t know, maybe it was because it was Sunday morning, maybe the speaker didn’t seem too comunicative, but the slides were a mess, jumping from one presentation to the other, in a boring, static enumeration of Spring characteristics. I would have liked a presentation about 3 or 4 key points, with some good live examples showing me how simple and effective it is, instead of wasting 15 minutes about AOP support in Spring, talking about AOP in a way that doesn’t really stand in front of Brian Sletten presentation. I think that this session needs to be redesigned completely. This is the real only black-hole in the whole 2 days.
With a friend of mine we’ve run away to Andrew Glover’s Groovy session: Practically Groovy: Real World Groovy for Thrill Seekers and this has been the best decision of the morning. Andrew is a great speaker, very energetic and empathetic and Groovy is just fine, bringing back joy of programming to java stuff. The possibility of having a dynamically typed language with all the libraries and the ubiquity of the JVM has actually real possibilities. The standardization process driven by Sun may have positive effects, as long as it doesn’t become a mammuth. Some of the features that I’ve seen are really cool, like driving ant tasks in a more effective way compared to what ant itself does. Or super simple XML builders and slurpers. Everybody should give Groovy a try and Andrew was great in communicating this to the people: this is what I especially appreciate in a speaker, having distilled useful information and coming back from the session with the desire to actually try some of the things that I’ve seen.
I attended Ted Neward’s Effective Enterprise Java: State Management next. I know Ted by reading his posts in the Advanced Java mailing list and I’ve always wanted to see a presentation made by him. He is awesome, brilliant, caustic. The session was chaotic, completely out of sync with my expectations but enjoyable. I was hoping a more thorough coverage of transient state management, with issues like session replication, etc., but that’s ok.
Before lunch I’ve chat a little bit with Scott Davis. He has told me that there were roughly 75 attendees, which is not bad if you think that this is the first time here in Toronto. In Calgary NFJS started with more or less the same partecipation and it has now doubled the number of attendees.
After lunch there was some sort of panel of experts discussion. To be frank, it resembled more an old friends riunion and if anybody had a pint of beer in their hands it would have seem more realistic to me. But it was entertaining to say the least. A couple of shots, in no particular order, of course without possibly remembering who said what:
- “SOAP is the EJB of the XML world”
- Cargo is an interesting container, very test-friendly
- Using Bad Boy to record HTTP interactions for JMeter
- a funny argument between Scott Davis and Ted Neward, the former leaning towards REST web services, the latter more towards SOAP web services
- Rails and ruby are definitely big things, even though nobody can say if they will hang around 5 years from now, but one thing is sure: Rails has definitely changed the way we approach development for the web
Scott Davis is a brilliant guy, so after lunch it was his turn with Real World Web Services. I like the semplicity of REST web services, and Scott explained clearly what a REST web service should look like. Maybe the first half of the presentation was a little bit too introductory, but the second part had some nice examples.
Last but not least, Andrew Glover gave an Introduction to TestNG, the next generation testing framework for developers. I have to confess that I really didn’t like the way TestNG emerged, theoretically fixing JUnit flaws. I’ve seen almost nothing related to TestNG that cannot be obtained in JUnit as well, requiring a deep knowledge of the framework and with some creativity of course. On the other side, opening a discussion around enhancing unit testing can only bring to better tools. JUnit 4 has introduced some stuff, like usage of annotations, probably only because TestNG people were talking about it. Apparently, the TestNG community is also more diversified, while it is almost impossible to contribute to JUnit (committers are just a bunch of people, Beck & Gamma included). Anyway, I don’t think I’ll jump to TestNG immediately, but it was definitely interesting taking a look at it.
At this point let me sum up the things that I’ve particularly liked:
- Sessions of 90′ are intense and wide enough to provide a decent coverage of the topic
- Almost all the speakers were excellent communicators and all of them are well prepared
- Level of attendees seemed high as well, not a bad thing when it’s a matter of chatting a little bit after lunch or during breaks
- Being able to check all the slides well in advance so that you can choose where to go (there were always 4 parallels sessions here in Toronto)
On the downside, I’d say:
- Too much focus on java from my point of view, even though I understand this is what makes the event attractive for a lot of people
- In particular, I was hoping for some more ruby
All in all, it was great, I definitely recommend it, it is worth any single penny. Maybe not really everything is just stuff, but fluff is so rare to make it really worth.