Skip to main content

TheServerSide Symposium - Day 2 - May 7th, 2004

Posted by kito75 on May 17, 2004 at 1:45 PM PDT

I began the second day of TheServerSide
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,

Compuware's solution to MDA is a product called ">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 ">Hibernate</s>
and a fellow Manning
. 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, href="">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="">;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

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

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 href="">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
  • 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.

Related Topics >>