Wow, TSS was great. I am really counting my blessings that I work for a company that understands how much we can gain from sending employees to these things. In my previous company, I would have had to been able to prove beforehand that something I was going to learn at the conference would solve a particular existing problem and that going to the conference was the most cost-effective way to learn this. Argh.
I attended sessions on SOA/ESB/MOM, Spring 2.0, EJB 3.0, AJAX, AOP, Business Rules, Seam (the new framework from the author of Hibernate), Shale (the new framework from the author of Struts), and more. Here are a few of the major themes or exciting or interesting ideas that I gathered:
Spring 2.0 looks fantastic. Bean management is much easier, you can manage beans that weren't created in the bean context, and you can even assign a runtime scope and 'backing store' to a bean, such as the HttpSession. Spring 2.0's integration with AspectJ (with or without compiler dependencies) makes the AOP much more powerful. EJB 3.0 is just catching up to where Spring 1.0 (actually 0.9) started, with AOP based on proxy-based interception, and that's all the EJB-evangelists think we are smart enough to handle. True AOP with AspectJ, however, is awesome, but I think we would have to work on our naming and packaging standards to really take advantage of it at my company.
Rod Johnson also had what to me was the most profound statement of the conference, which really brought home to me the importance of the 'POJO' programming model. He pointed out that "No existing web technology will be primary in ten years, but we can design domain models today that could last beyond that" (paraphrase). Several presentations recommended that everyone should read Eric Evans' 'Domain Driven Design' and stressed the importance of building a good domain model and keeping it free of API dependencies. I'm glad to see that we're finally getting around to some actual OO programming in Java!
One big question on everyone's mind is "What about EJB 3.0?". Well, this conference definitely has its bias, and unless you were at a presentation directly aimed at promoting EJB 3.0, the general attitude was "too little, too late". At the keynote panel discussion, Bruce Tate said "EJB is dead, and Rod killed it." Rod himself seemed mainly frustrated by the limitations of the EJB 3.0 proxy based interception, and asked how anyone could get excited by that when they've already had it in Spring for years now. However, even the EJB 3.0 naysayers agreed that the JPA is a good thing, and so I am in the middle of updating the new DAO layer that I was preparing to introduce at my company so that it conforms more to the JPA standards. This was actually a really nice outcome for me, since I've been trying to decide what is truly generic and what is specific to Hibernate, and now I can just rely on the set of abstractions that the JCP has agreed to, which are based on the best practices of both TopLink and Hibernate and other such tools all merged together.
The sessions I attended on SOA/ESB/MOM gave me a good sense of how powerful these tools can be for integration purposes, but still left me convinced that we need to design specific APIs that target local and remote clients separately. I'm not sure if my question was fully understood, but I asked about this at the keynote panel, and the panel seemed to react as if there was no question but that of course SOA et.al. is just about integration.
There was of course all the hullabaloo about scripting languages and Ruby on Rails, but I didn't go to the RoR session or Bruce Tate's 'Beyond Java' so I didn't hear a lot from that side. At the general sessions people seemed to think scripting in the JVM would be a good thing, but that the JVM support would take a while to mature. Spring 2.0 does allow scripting beans in Groovy or JRuby.
The JRules presentation I went to was the most impressive vendor presentation I saw, in fact one of the best I've ever seen. I've heard about 'business rules' and 'rules engines', but wasn't quite sure how I would go about using them. I've also been interested in all the talk about 'domain specific languages' lately. What I saw was basically a domain specific language editor/manager that maps directly onto your Java-based domain model. Their editors and server products seemed to provide everything you could ask for -- auto-complete when editing rules, versioning of rules and publishing lifecycle management, and pretty much anything that anyone in the audience asked about. I don't know if other products match this one in terms of the tool support, but that was what really sold me. The ease of using an existing Java domain model and exposing it as a 'domain specific language' was quite attractive.
Both Gavin King's Seam and Craig McClanahan's Shale were impressive JSF-helper frameworks, but Craig is a much nicer guy and his framework doesn't depend on JBoss. What was nice about both of them had a lot to do with managing 'conversational' state. I had to support the editing and rollback of changes across a huge object model at my last job, and managing the state properly with back buttons and multiple browser windows was a nightmare. These frameworks make it all very easy. If you plan on looking into JSF, I would definitely recommend that you also check out Shale.
As an aside on Gavin King, I have long noticed the hostility from the Hibernate community against Spring, and the negative energy does seem to emanate from Gavin. He is fond of calling everyone else stupid, where people like Rod and Craig were sympathetically looking for ways to help us understand the complexity of enterprise development. Gavin's big complaint against Spring in his presentation was that it didn't handle the conversational state, and therefore the reason everyone gets 'LazyInstantiationException' all the time is because they're using Spring. This is just wrong. Whether you're using Spring or bare Hibernate, you have to choose how to manage the lifecycle of your Hibernate Sessions. He can't blame the fact that people don't understand how to use lazy ORM on Spring anymore than he ought to feel compelled to accept the blame for their misunderstandings himself. Besides, Spring 2.0 /does/ handle the conversational state now, and you don't need Gavin's JBoss-dependent Seam framework to do it.
Finally, there were several caching/virtualization/clustering products on display, but I'd have to know more about the physical deployment architecture at my company (I'm still relatively new here) to gauge whether they might be worth investigating for me. The one piece of this I did get a kick out of, however, was one vendor showing how they could make your physically-separated web and business tiers behave or appear as if they were on one logical machine, and I kept thinking about why the heck anyone would separate them in the first place anyway. This has long been one of my pet peeves with the paradigmatic J2EE architecture, and is also the root of much of the DTO nonsense that pervades our industry. Always remember Martin Fowler's "First Law of Distributed Object Design: Don't distribute your objects!" (PoEAA, p.89)
All-in-all a great conference. If your company supports it, I definitely encourage everyone to attend these things. It's really invigorating to get doused in all the cutting edge ideas (even if some of them have actually been around a long time).