| 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.
|
