RE: Opinions Wanted -- WEB400

I'm not picking on Brad, I'm pointing to the general audience here, but
Brad knows me and is the least likely to take offense, so I'll use his
post as a jumping off point <grin>.

WebSphere is not difficult.  The WebSphere Application Server is a
simple J2EE container, which basically means servlets and JavaServer
Pages.  Ignore the EJB crap, which I'll address in a moment, and J2EE
really is nothing more than servlets and JSP.

One problem might be that there are some pretty bad ways to program
servlets and/or JavaServer Pages.  But the CORRECT method, know as JSP
Model II, is SO EASY that if you've ever programmed a 5250 display, you
can program this.  This is NOT the high-blown academic OO Java crap that
Java consultants try to sell.  This is really simple stuff.  Follow me
here:

Browser makes request.
Servlet takes request and passes it to RPG program.
RPG program determines the next page to display.
RPG program determines data that displays on that page.
RPG fills a buffer with that data and sends to servlet.
Servlet formats buffer into a bean.
Servlet displays next page.
Servlet reads data from page.
Servlet sends data to RPG program.

Folks, this is the 5250 architecture we've been doing for years.  On the
RPG side, determining the next page is the same as determining which
record format to display, and filling the buffer is the same as filling
the fields in the display file.  Unless you're one of those folks that
uses database fields in your display file (a generally frowned upon
practice in my neck of the woods), then you're already doing this.
Instead of a display file, you use an externally described data
structure and send that via data queue to the servlet.  If you can't
handle this, you have no business in application development.

The servlet side consists of EXACTLY two functions: one parses a data
structure and sticks it in a Java bean (the Java equivalent of a data
structure), while the other reads a POST request and sticks the POST
variables back into a data structure.  Yes, it's Java code, but it's
maybe a couple of hundred lines of Java code, and YOU WRITE IT ONCE.
After that, the only thing you have to add is the occasionally new data
when you add a new program.  Oh my.

Finally, the JSP side of things is like this:

<jsp:useBean class=com.mycomp.Bean1 id=mybean />

<TABLE><TR>
<TD><%= mybean.getFormattedField("MYFIELD") =></TD>
<TD><%= mybean.getFormattedField("MYFIELD2") =></TD>
</TR></TABLE>

This is as easy as any of the CGI template languages out there.  And the
beauty of this is that in order to change the format of the page, you
simply edit the JSP and, without changing a line of RPG, test it again.
And while you may be able to mimic some of this with CGI, it's never
going to be as fast or as powerful as JSP, because the JSP engine is
built from the ground up to do this sort of stuff.  For one thing, while
the CGI has to be re-interpreted over and over, the JSP is converted to
Java the first time it is used, and in turn is eventually compiled by
the JIT compiler to machine code.

Finally, there's the testing aspect of this.  You can test all of this
right inside WDSC, in the WebSphere Test Environment (WTE) where you can
set breakpoints in the Java code and even in the JSP itself.  Even if
your JSPs end up a little more complicated than normal, you can test
them right in the WTE.  You don't even have to connect to the host; you
can write dummy classes to populate the beans if you need to.

In my opinion, if you say WebSphere is difficult you simply haven't done
it correctly.  You may have tried generating some code with some
wizards, or maybe copied a servlet from somebody who didn't have a clue
how to write tiered applications, or you've had a consultant who knows
enough Java to be dangerous but doesn't have enough common sense to
program a subfile.  There are people out there still pushing useless
garbage like EJB or technologies that are already past their prime like
Struts.

Me, I regularly teach people how to use WebSphere and Java in a couple
of days (or even a couple of hours), and within a week they're taking
ownership and adding their own stuff to it.  No third-party packages, no
Open Source jar files, no custom tag libraries, no magic stuff.  Just a
few basic components.  There's an architecture out there affectionately
called "The Pluta Pieces" that is being used to build lightning fast
browser-based applications where the vast majority of the code is in
RPG.

The browser is just a UI, and the UI requires only a thin veneer of
pretty generic functions.  Anybody can do it.  You just need to see it
in action once.

Joe


> From: Brad Stone
> 
> "Brad, we tried websphere, etc.. etc...  tell me about
> eRPG..  we've not approached it but after websphere, we're
> open to anything..."