Struts, Spring, Tapestry, oh my!

Erich Pletsch erich at
Thu Aug 11 09:51:27 MDT 2005

   Jonathan Ellis wrote:

On Wed, 10 Aug 2005 17:58:00 -0600, "Erich Pletsch" [1]<erich at>

If you prefer simple, but have a bunch of Java developers at your
disposal, consider JSF.

Man.  Twice in one day, I'm marveling at how huge the gap betwen
"Jonathan simple" and "J2EE simple" appears to be.  It's like I'm living
in some kind of parallel universe.

   What's your idea of simple?  So far you've bashed Java and the J2EE
   architecture as overly complex, but I haven't seen you suggest a
   viable, enterprise class alternative.
   Is "Jonathan simple" Windows?  I wonder what you would have said when
   Linux first came out.  Certainly it was very complex to learn and use
   when compared with the "Jonathan simple" alternatives (windows, mac,
   etc.)  that were available at the time.  However, just because
   something isn't the simplest solution, does not mean that it's not the
   best.  Nor does it mean that over time that complex solution will not
   evolve to something much more simple.
   I take as case and point EJB.  EJB 1 & 2 are very complex and obtuse.
   EJB3 is much better.  Why?  Someone came up with a much simpler way of
   dealing with ORM persistence mapping - Hibernate.  Then Sun hired the
   creators of Hibernate to create EJB3 based on the hibernate model.
   However, because Sun was behind EJB they went to the trouble of making
   EJB3 completely backwards compatible with EJB1 & EJB2 and they also
   invested significant resources in making sure the EJB3 will scale just
   as well as EJB1 & EJB2 scale.
   That's another reason to choose JSF.  It's not going away and
   everything you write now will work in future versions - unlike Struts
   which breaks your code every time they do a minor version change.
   The point of this rant is that simple is not always best.

Here's one example just for fun.

So they took all the problems the ASP.NET-style leaky abstraction gives
you, and on top of that made you have to write idiot boilerplate like
FacesContext context = FacesContext.getCurrentInstance();

to get anything done.

I'm glad it works for you, but I don't think you're (and by "you" I mean
"java developers on the plug") helping your case by calling stuff like
this "simple" in the context of a Linux UG.  Many of us still buy into
that whole "small is beautiful" thing.

   Again, the whole point of JSF is to get you out of that code.  You
   don't have to write
FacesContext context = FacesContext.getCurrentInstance();

   Unless you're coding JSF manually.  And, although I believe everyone
   who uses JSF should learn how to code it manually (and understand what
   that line of code actually means and does) you never actually have to
   write it if you're using a decent IDE.  The IDE should create all of
   the basic XML configs, backing beans, etc. leaving the programmer to
   focus his efforts on the back end code.
   Most of what you do in JSF is use a simple taglib to lay out the
   interface in the html page.

JSF is a relatively new standard that is being highly touted by Sun
Microsystems.  They hired the creators of Struts to create the JSF
standard and to help write the reference framework.  Please note that
JSF is a standard, not a framework, and that several competing
implementations of JSF are available.

Fantastic.  Meanwhile, Microsoft continues to eat Sun's lunch by
providing solutions that

a) really do bear some resemblance to being "simple" in the normal,
non-J2EE-developer sense of the word, and
b) aren't fragmented by various vendors trying to "value add" their way
into incompatibility.

   If Sun were trying to make money on Java then their investors would
   have forced them to stop developing it years ago.  Java doesn't
   effectively sell Sun hardware or software - Sun's actual money
   makers.  However, Sun invests millions annually into Java development
   and continues to push more and more of their products into the open
   source community because Sun believes in the open source model.
   What you're really saying here is that Microsoft's model is a good
   thing - that proprietary benefits the developer because it's simple.
   However, the history of Linux and of the open source community in
   general would say otherwise.  Open and competing standards eventually
   lead to better, less expensive, more stable products than the products
   that come from proprietary vendors.

Six months ago JSF was relatively unknown and was not worth much because
it was very shallow (in terms of components and support).

Why is JSF gaining so much momentum right now?

It is?

Maybe you're right; I only barely pay attention to J2EE these days but
if it were gaining as much traction as you're saying I think I would
have noticed.

   As you said, you're only barely paying attention.
   [3] and [4] have both had
   quite a few articles about JSF over the past 6 months.
   You'll also find resources on both IBM and Oracle's web sites that
   tout the technology.  However, you will not find much on Microsoft's
   web site :)

Which IDE to use?  Well, I've had my programming team try four and this
is what we decided:
1.  First we tried Java Studio Creator version 1.  It worked o.k., but
it didn't have all the components we wanted.
2.  We looked at Oracle's JDeveloper which has a lot of great components
(but realized that you have to license the ADF objects if you aren't
running it on OAS so we dumped it)
3.  We used an eclipse plug in.  It did the XML stuff o.k., but it
didn't have WYSIWYG page editing.
4.  A few weeks ago Sun announced Studio Creator 2 in beta.  So we
switched and has been a lot better.

Studio Creator 2 beta is a huge memory hog, and it's a little sluggish
at times (hopefully they fix that before they release it).

Ahh, the price of simplicity...

   I'll reserve judgment on JSC2 until the final release version is out.
   Meanwhile, the beta version seems to work good enough for me.  And it
   runs on Linux and OSX, which makes my developers happy.

| This has been a P.L.U.G. mailing. |
|      Don't Fear the Penguin.      |
|  IRC: #utah at   |


   1. mailto:erich at

More information about the PLUG mailing list