From: Nathan Andelin
If a user presses and holds down an arrow key, the highlight bar moves
from row to row in the list at a rate of about 20 rows per second, and
the server is flooded with the same number of requests per second. If
10 users are doing the same thing at the same time, then the server
may
be flooded with about 200 requests per second, but the interface is so
efficient that I can offer applications with this level of interaction
and not worry about performance degradation caused by a high level of
activity.
Nathan posted this about a month ago, and I noted that I would try to
emulate this approach with EGL. The new version was recently released and
after the holidays, I tried to implement a version of his interface.
I started with my old train line application, which starts at the highest
level with a list of train stations and when the user selects one, the list
of stations for that line appears. I then put the business logic into
servers and web-enabled the UI using EGL.
In the standard page-to-page JSF approach (equivalent to a 5250 drill down),
I added a "next line" button to the station list page which causes the
application to fetch the next line and repopulate the station list. I can
hold down the page down key and get 60 requests a second. This is so fast
that the page doesn't have time to refresh and indeed it eventually leads to
overload on the server. If a user manually hits the page down key
repeatedly, the refreshes look instantaneous (it take about 16 milliseconds
to refresh the page) and they can't overload the machine.
I then created an AJAX version of this, in which the line table is on the
same page as the station table. You can use the keyboard to scroll through
the lines on the table and as you do the selected line is highlighted and
the station table repopulates. AJAX is a little better at self-regulating
so that holding down the accelerator key doesn't cause server errors. On
the other hand it's a bit slower. How slow?
Eight pages a SECOND. Okay, it's not 5250, but it's web-based, and I didn't
have to write a single line of Java code.
And I didn't write much EGL, either. The entire back end is RPG. The EGL
calls a server program in a loop to load an array. A half-dozen lines of
EGL code, which can be encapsulated in a library routine. But what's so
impressive is that the page requires about 20-30 calls to the RPG program,
which is running on a different machine over a little bitty 100MB LAN.
That's works out to about 200-250 calls a second in the AJAX version and
well over 1000 per second for the page-to-page design. And of course the
System i isn't even breathing hard.
I'll have videos of this stuff available just as soon as IBM says I can.
I'm also working on a RESTful interface that may fit in even better with
Nathan's architecture, as it will invoke the back end logic using a web
services type of approach (well, REST in this case as opposed to WS-*, but
that's a programming technicality).
Joe
midrange.com
