I began the second day of TheServerSide symposium with the morning's Power of Patterns keynote by Compuware's Mike Burba. In front of a full room, Mike discussed patterns as a general concept beyond the basic GoF and J2EE patterns we often think about. He defined them as common solutions to common problems in a given context, noting that they exist at the domain, platform and application levels. He also pointed out a study by Sun that claimed developers who used patterns were 5x faster than those who didn't.

The problem is that people don't model all of these patterns, and the solution – surprise! – is model-driven-architecture (MDA). The basic idea is that you start with the domain model, which is platform independent, and then transform that into a platform-specific application model, which can then be transformed into code. The process doesn't remove all coding, but it does minimize the effort. It should also be iterative, so the models and code evolve together. MDA is more than just application code, and can be applied to all parts of the development lifecycle (unit tests, QA scripts, etc.)

Compuware's solution to MDA is a product called http://www.compuware.com/products/optimalj/default.htm ">OptimalJ, which has transformations for data access, EJB, struts, and so on. You can also build your own custom transformations. This sounds similar to Rational XDE's MDA, which I reviewed last year, so it'd be interesting to see how different the two products are. I haven't personally used MDA in a real project, but conceptually it sounds good, and I do like drawing pictures quite a bit :-). I'm not yet convinced that it is the silver bullet of application development, though.

Next, I attended "From Hibernate to EJB 3.0" by Gavin King, the creator of http://www.hibernate.org/ ">Hibernate</s> and a fellow Manning author. I missed the session on EJB 3.0 the previous day, so this was an opportunity for me to learn about how Gavin was going to help fix that evil they call container-managed persistence (CMP). The room was packed, and Gavin delivered his talk in a fast-speaking, fidgety manner, often referring to himself as "annoying." I'll write about this session separately, but the main point was that EJB 3.0 is going to leverage JDK 1.5 attributes, allowing you declare a POJO as an EJB instead of requiring you to implement 20 different interfaces, and it will use a lot of Hibernate's features, deprecating CMP as we know it. Hibernate will continue to be separate product (now part of JBoss), innovating in its own right.

After the Hibernate session, I ran into Ted Neward, the well-known editor of TheServerSide.NET, and one of the few people who has successfully mastered both Java and .NET. I reviewed Ted's first book, Server-based Java Programming several years ago, but we had never met in person. We discussed the reaction of many Java people to .NET (so many of them dismiss it). Ted made a good point: a lot of people are simply scared. He's seen situations where Java developers were actually replaced with .NET developers, which is the worst fear of us all, especially when there's a dearth of hiring. Whether or not it ever makes sense to replace good developers instead of training them is a different story...

We also discussed some of the features of the two platforms, and Ted mentioned his love of delegates in .NET, which I share. Type-safe method pointers are definitely a good thing, and I think they're cleaner than interface-based listeners. Method binding expressions in the JSF EL (and presumably the equivalent in OGNL) let you reference a method directly, but they're not evaluated at compile-time, which is part of the beauty of delegates.

Ted prefers J2EE, but likes .NET's Common Language Runtime (CLR) better than the Java VM. It would, however, be pretty sad if the CLR didn't have some enhancements over the VM, since Microsoft had years to tinker with the VM's code. As a matter of fact, a lot of the original .NET code was evolved from Visual J++, which might have had something to do with the recent sizable settlement between Microsoft and Sun...

After chatting with Ted, I ran over to Doug Cutting's session on using Lucene for the web. I missed the portion where he talked in detail about Lucene, which is a shame, since I was interested in learning more about it. The latter half of the talk was about Nutch, Doug's search engine that's built on <"a href=" http://jakarta.apache.org/lucene/docs/index.html">;Lucene;. I had attended a Nutch talk the day before, so there wasn't a lot of new material – just some lower-level Lucene details that were useful to existing Lucene users.

Next, I went to lunch, which was sponsored by Macromedia. Christophe Coenraets gave a presentation about their Flex product called "Extending Java and SOA with a Rich Front End". I've been interested in Flex, a component-based user interface framework built on top of Flash, for quite some time. I was even one of their beta testers, but unfortunately I never had time to really play with it. The basic idea is that you can build a rich front end that will work with any Flash-enabled browser (estimated at 98% of all browser installations), and integrate with web services and existing Java applications.

After the session, I asked Cristophe my obligatory question about their plans for JavaServer Faces (Macromedia was a member of the JSF expert group). He said that they were looking for ways to integrate JSF with Flex via render kits. Flex is a key technology to watch – I'll be writing more about it later.

I split the next block of time between Mark Hapner's presentation on Java Business Integration (JSR 208) and Jason Carreira's WebWork presentation. I've never been deeply involved in the web services space, which is the focus of JSR 208, so Mark's talk was fairly foreign turf from my perspective.

Jason's talk, however, was right up my alley, and it was quite informative. My impression was always that WebWork is superior to Struts, and now I can see why. Like Tapestry, WebWork uses OGNL for expressions. One of the features I particularly liked was the value stack, which allows you to reference properties from any object in the stack by name, eliminating the need to worry about what object is available, and where (you only have to know the property name). Also, like Tapestry, you can define user interface components in templates (a feature that JavaServer Faces lacks). WebWork doesn't have as rich of a view of a UI component as Tapestry and JSF, though.

Although I like a lot of WebWork's features (and what I saw of XWork), it still focuses on HTTP's annoying request/response programming model. I've become convinced that a higher-level event-driven model, like the ones provided by JavaServer Faces, Tapestry, and ASP.NET Web Forms, are the way to go. So, after the show, I asked Jason if anyone had talked about integrating JSF components with WebWork, and he said that someone had volunteered to do that, but he hasn't seen any code yet. This is a point I often try to stress to people about JSF: it doesn't require JSP, and you don't have to use JSF as the primary controller. It's entirely possible to use JSF components with other frameworks. If we can get JSF component support in all of the popular web frameworks, there will be a great opportunity for UI component marketplace, which will make everybody's life easier. Struts already has JSF integration, and this is something I explain in my book.

Next, I attended Darren Broemer's "Applying Architectural Style to an IT Organization" session. This one sounded particularly interesting to me, since I'm often trying to apply "architectural style" – enforcing a set of requirements and policies that ensure the cohesiveness of the code base, and encourage reuse. In my experience, it's often like pulling teeth and herding cats at the same time. I suppose Darren had some good competition, because the room was sparsely attended. At any rate, he gave some quality advice, pointing out that having an official, management-supported role is key, and emphasizing the necessity of formalizing best practices. He also said that the key to communication was actually working with people hands-on, a point with which I strongly agree.

The highlight of the day was Mark Fleury's entrance for his "Professional Open Souce and Projects" dinner keynote. Since The Middleware Company had given him the Joker card in their Who's Who in Enterprise Java list, Mark, always the showman, entered as the Joker – from Batman, that is – with a full entourage that included catwoman and the riddler. I'm not kidding – he had full makeup, and the costume too.

The keynote itself focused on one of the conference's resounding themes: aspect-oriented programming (AOP). Mark (who is JBoss' CEO) discussed middleware as a collection of aspects and the ability to inject EJB functionality with annotations. He also made a good point about AOP – in order to use the AOP features of JBoss (which are shipping today), you don't need to use AOP per-se. AOP is just part of how you use the product.

He did, however, go on to say that just about everything – quality of service, the IoC and Observer/Observable patterns, as well as 50% of the Gang of Four patterns – can be implemented as aspects. Mark also discussed JBoss' current product line, which includes JBoss Application Server, JBoss AOP, Hibernate, JBoss Cache, Nukes on JBoss, Javassist, and Tomcat. If you're wondering why Tomcat is on that list, it's because Mark claims that the JBoss group controls 45% of Tomcat's development. Whether or not that makes Tomcat a JBoss project is a different story.

After dinner, it was time for one more session – the "Future of Enterprise Java" panel, moderated by Ted Neward. The panel members included John Crupi (Chief Java Architect at Sun), Gregor Hoph (Integration practice leader at ThoughtWorks), Linda DeMichiel (EJB 3.0 Spec Lead), Mark Hapner (Spec Lead for J2EE 1.4 and JSR 208), and Benjamin Renaud (Deputy CTO of BEA). There were a couple other people on the panel, but unfortunately there names weren't listed, and my thumbs can only type so fast :-).

I didn't do a full transcription, but here are a few main points from the panel and the audience:

• Metadata will have a huge impact on future enterprise applications
• Application servers are evolving into integration servers (BEA's recent growth in the integration server business is good evidence of this)
• Lightweight services will be everywhere
• We'll see more process modeling, orchestration, and scripting languages
• Jini has features that are suitable for enterprise use, but it probably won't have an impact anytime soon
• Innovation needs to happen around tools in order to compete with .NET; good tools don't necessarily mean lack of power or features
• No one seems to have a good answer for how Java will effectively compete with .NET on the client; Sun will try to address this with future versions of Java Studio Creator; Flex might be an option
• BEA will be open sourcing parts of WebLogic to help spur tool innovation, even though most people agree that open source isn't usually focused on developing tools (except for Eclipse)
• The EJB 3.0 expert group will look into allowing EJB 3.0 support without backwards compatibility (for frameworks like Spring), but major vendors will still provide it

Afterwards, I asked Benjamin what his plans were for JavaServer Faces support; BEA was a pretty silent member of the JSF expert group. He said that they intend to support JSF, and that they will be open sourcing parts of their implementation. It'll be interesting to see what happens when BEA starts opening up their code.

After the roundtable, I headed off to meet some friends for dinner and nurse my hangover with a few drinks.