Struts, Spring, Tapestry, oh my!
erich at uvnet.net
Thu Aug 11 09:51:27 MDT 2005
Jonathan Ellis wrote:
On Wed, 10 Aug 2005 17:58:00 -0600, "Erich Pletsch" <erich at uvnet.net>
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
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?
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
As you said, you're only barely paying attention.
http://www.javaworld.com and http://www.onjava.com 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 irc.freenode.net |
1. mailto:erich at uvnet.net
More information about the PLUG