| October
1999
Javelin paints
a thin, secure Web front end
Minisoft’s
Java-based emulator brings applet access for 3000
programs
Review by Shawn
Gordon
Have you ever
wanted to open up a terminal to your HP 3000 from a Web browser?
Maybe you tried using Telnet and noticed that while you can connect
and do some basic things, you can’t get any good emulation.
Javelin from MiniSoft allows you to do exactly that. Javelin is a
Java applet that is a full-featured terminal emulator that downloads
in just 100K of space.
This connection
gets you pretty much everything you need for working on the HP 3000.
It includes full terminal emulation for character and block mode as
well as local printing capability. The only things it doesn’t
support (both offered by MiniSoft’s MS92 standard emulator) are
the ability to do file transfers and a scripting language. For most
applications this shouldn’t be an issue.
How does it work?
You can start up
Javelin by either setting up a Web site that contains a link to the
Javelin start-up HTML, or by dragging the HTML and dropping it into
Internet Explorer. It will make the connection to your HP based on
whatever configuration information you have defined in the HTML file.
After a few moments of starting up, you will be presented with your
emulator window; see Figure 1 below for an example of Javelin running
Glance on the HP 3000.
The details of
how this all works elude me, but I was pretty impressed by the
ability to get an HP terminal emulator running with just 100K of Java
code.
Features
As already
mentioned, Javelin can make either Telnet or NS/VT connections to
your HP. All that is required is for you to use the appropriate HTML
file so that the correct portion of the applet is used. In both cases
you can modify the sample HTML files that are provided however you
wish, but all you should need to do is add the IP address that you
are concerned with. Here is what the NS/VT example looks like with my
IP address in it.
<html>
<head>
<title> Javelin-HP Emulator by
MiniSoft</title> </head>
<body>
<script
LANGUAGE=”javascript”>
var an = navigator.appName;
if (an != “Netscape”) {
document.write(“<applet
code=\”J92.class\” id=\”J92\”>”);
document.write(“<param name=\”cabbase\”
value=\”J92.cab\”>”); }
else {
document.write(“<applet
codebase=\”./\” archive=\”J92.jar\”
code=\”J92.class\”>”);
}
document.write(“<param
name=\”Hostname\”
value=\”141.199.1.2\”>”);
document.write(“<param name=\”Hostport\”
value=\”1570\”>”); document.write(“<param
name=\”Protocol\” value=\”NSVT\”>”);
document.write(“<param name=\”Config\”
value=\”BkEnt80.j92\”>”);
document.write(“</applet>”);
</script>
</body>
</html>
As you can see,
this is pretty straightforward — there isn’t a lot of data.
You can configure color as well in the HTML file, but everything else
needs to be configured in the Javelin configuration file.
The Javelin
configuration file lets you configure about 20 other parameters, such
as a default logon so the user is immediately logged on, display
rows, load the user function keys, default printer information, etc.
This is actually a good feature — the Javelin emulator allows
for local printing. This might seem trivial, but it’s a huge
issue. The neat thing about the LOGIN verb is that you can send up to
six commands. The limit of six seems rather odd and arbitrary, but it
would allow you to do something like log on, stream a job, and log
off without the user ever having to get involved.
The developers of
Javelin hold an Encrypted Digital Software Publishing Certificate
issued by Verisign. This certificate is attached to the Javelin
cabinet file using Microsoft’s Authenticode technology. This
protects the file from unauthorized modification by a third party.
The point is that Javelin is fully SSL compliant and is extremely
secure.
When the browser
runs Javelin, it notifies the user and gives the user the option to
run or not to run the applet. This technology enables Javelin to
bypass the restriction in Java that would otherwise prevent it from
accessing hosts other than the one that downloaded Javelin.
There is a
fascinating development in process at MiniSoft called the Javelin
Designer. The idea behind this product is to allow you to surround
your conventional applications written in COBOL/VIEW, Powerhouse,
Speedware, etc., with graphics and sound and make them available via
the Web inside of Javelin. The designer would create HTML code that
would support all of these functions and features and basically hide
the application that is really running behind the scenes.
I did not have an
opportunity to look at the Javelin Designer in time to get this
review out, but Minisoft says the product will be available by the
end of the year. We’ll take a look at it when it surfaces.
Installation and
Documentation
You can either
download the demo from the Web, have MiniSoft e-mail it to you, or
have them send you a diskette. The installation can be confusing, but
all you have to do is put their sample HTML file on your Web site
with the appropriate link, and you are done.
The documentation
is very clear, concise and well-organized. You should have no trouble
installing, configuring and using the Javelin applet.
The TestDrive
I had the
software e-mailed to me and it took me just a couple of minutes to
install it, edit the config file for my IP address, bring up Explorer
and then drop the sample HTML file into Explorer. My emulator came up
and I logged on. What I was most interested in was faithful emulation
and scroll speed. The scroll speed isn’t bad, but it’s not
amazing. The typical use for this type of product would be for
someone who is running applications on the HP 3000 for whom scrolling
shouldn’t be an issue.
To test emulation
support I first ran Glance to see how Javelin handled its rather odd
interface. I was able to bounce around all through the application
without a problem. Next I ran some programs that use my
pseudo-windowing driver for a window. This driver makes use of just
about every display escape sequence you can possibly name, so
it’s always a good exercise. Again, I had no problems at all
— all the cursor control stuff was sensed as well as the
FCONTROL calls to perform various functions on the
terminal.
Finally I tried
running NMMGR as an example of funky block mode. This worked just
fine as well. The thing you have to keep in mind with block mode,
however, is that Javelin will let you define the two Enter keys on a
PC keyboard to be either Enter or Return, but you can’t split
their meaning. That means the numeric keypad can’t mean one
thing and the alphanumeric one mean something else.
Conclusions
I’ve got to
say that I was impressed. This product really worked well, and I can
see environments where it could definitely solve a variety of
connectivity issues. This opens up a lot of possibilities for
creating Web-based applications that don’t need to be rewritten
to be Web based applications — you just fire off Javelin and
connect and run your app.
This is exactly
the idea behind the proposed Javelin Designer that I spoke about.
It’s supposed to have the ability to create nice looking
Web-based front ends to legacy systems without changing anything
about the way the legacy application works. It’s a very thin
client, because all you have to do is paint the screen and pass very
minimal amounts of data.
Javelin does what
it’s advertised to do, and it does it well. I’ll be looking
at Reflection EnterView from WRQ
next month, which is their Java-based emulator, so watch for the
comparisons.
|
