VOICE Home Page: http://www.os2voice.org
[Previous Page] [Next Page]
By: Isaac Leung ©May
Simplicity for Java is a product of Data
Representations, located in Springfield, New Jersey. They claim to have been
in business since 1997, which I suppose is an eternity in computer years.
Simplicity is an IDE (Integrated Development Environment) created with 100% Pure
Java. So yes, this means it will run on any platform with a good JVM (Java Virtual
Machine). They claim it's "The simplest way to create Java Applets and Applications".
It comes in a regular version, and a "Professional" version, which adds
extra features for to ease development of database access applications and server
side applets. I purchased the regular version since I didn't need the extra functionality.
Those of you hoping to be disappointed by their claims, well, you won't be. It
easily lives up to its claims and is one of those products that works as advertised.
Not so long ago, Java had a horrible reputation for being too slow and too buggy.
In my opinion, it was well deserved! But if you haven't been keeping up lately,
Java has made huge improvements. It may not be popular on the consumer scene yet,
but Java is busy working behind the scenes in many businesses. (Believe it or not,
it's near indispensable now -- the Cobol of the new millenium, some say).
So, how is Simplicity which is actually written in Java for Java?
Is it going to work well enough on your average machine? This is my main development
In addition, I also evaluated on the following platforms:
Yes, I'm aware that my systems may be loaded up with more RAM and may be a bit
speedier than what some of you run on your desktop. But then again, I'm already
well behind the leading edge, so I think these are reasonable test beds.
Simplicity is normally available as a download only (CD is available on request
at extra cost). Various packages are provided for WinXX, Solaris, MacOS, OS/2 and
a generic UNIX package. As mentioned before, Simplicity is 100% pure Java, so you
can run it on any Java enabled platform. The packages merely provide a platform
specific install script for convenience.
For OS/2, the installation is easy, if not the slickest. Just unzip into your
directory of choice. A short script is provided to create an icon on your desktop,
but that's optional, of course. And, ummm, that's it.
The Win32 package comes in an executable which uses InstallShield for Java. Slick?
Maybe, but easy? Not necessarily so, at least in my case. The first time was okay,
but when it came time to upgrade, uninstall or move the original directory, OUCH!
It didn't uninstall correctly or completely. Then I couldn't install the upgrade,
then I couldn't install the original version into any directory other than the first
one. Granted, all that really needs to be done is to unzip it somewhere and write
a short startup script... but you'd think the installer would install/uninstall
properly. Especially with something as simple as this.
Simplicity starts up relatively quickly, even with the loading of the JVM. It
certainly doesn't feel any slower than Netscape starting up, so I have no real complaints
in this department. After a brief splash screen, you are presented with a starting
dialog. Only 3 choices are presented. Open an existing project, Start a new project
or Go through the tutorial. The choices are pretty clear and obvious. Very nice,
already it gives a warm, friendly feeling :)
For everyone, I would recommend downloading the free trial version and going
through the tutorial. What I can describe to you in words or screenshots does not
do this package justice! You really have to try it yourself or see a live demo of
it to appreciate how easy it is to work with.
The heart of Simplicity seems to be the Composer and Object Palette. This very
much forces you to design the look and layout of your application before you actually
do any coding (if you need to do any coding!). Your own personal development style
When you start with a new project in the composer, you are presented with a blank
window. The first thing you are likely to do is to design a layout for your application.
Just go to the Object Palette, select the layout you want and then "drop"
it in the blank window.
Next, start adding things like text labels, buttons, checkboxes, whatever you
wish. The basic items are all provided in the Object Palette, as you can see in
the snapshot below. All these you can just select with one mouse click, then drop
it onto your layout. One thing to note, is that everything in Layout and the Basic
palette should be standard Java objects, with some exceptions (see my gripes below).
All the other tabs are extra goodies that Simplicity has created for your ease of
use, so you'll need to provide the .JAR file that comes with Simplicity
if your application relies on these.
Everything you add, even the layout item, is given a Object Name, which you can
change, of course. These are essentially your variable names (hey, Java is object-oriented,
right?) and you should change it to something meaningful. When you get a lot of
items in your application, sometimes they are not visible, so the only way to select
an object and work with it is via the drop-down box in the Composer window. Made
a mistake? No problem. You can just click on the part, go to the Composer window
and click the "Recycle" button. These items will all sit in the "Recycled"
tab on your Object Palette in case you want to use it again.
Up till this point, it's dead easy to use. Pretty much, it's like using a simple
drawing package. You've got yourself a pretty looking front end, perfect for screenshots
and enticing the VC's for more cash. But now you have to get down and make it do
something. Uh oh? Okay, time for a confession. I'm an engineer by training. I'm
a competent coder, but no match for the real programmers like my brother. I cut
my teeth doing first BASIC, then machine code on a Commodore 64. Now I've added
Fortran, C, Lisp, Smalltalk and Rexx to my repertoire. But I've never done Java.
I tried, honest, with IBM's Visual Age for Java 1.0, but I didn't make it through
the first tutorial. Simplicity lets you in real easy. I have to admit, I went through
only the first tutorial in Simplicity, because after that, I was just itching to
start (that and I had a deadline to meet :).
If you look in the Composer window, there are 3 tabs for each object initially.
One is for the type of object, so you can name it and change other properties. The
next one is labeled "Visual", and as you expect, it's for changing the
visual properties of an object, such as font, colour, etc. So the only one left
is labeled "Listeners" and that's all you have to know to start.
Most of the time, all you want to deal with are buttons or menus, so just click
the checkbox labeled "Listen for Action events". This will now an an extra
tab in the Composer window, labeled "Action". Of course, if you click
the other check boxes, it will add tabs accordingly.
Take a look at all that code. In this example, I've shown the "Load"
button for my application, which will pop up a file dialog, ask for the filename,
and dump result of the file into a variable. Scared yet? Well you shouldn't be!
Because I didn't write any of it! Okay, honestly, I decided to change a variable
name, but the point is, I didn't have to. All this was the result of that magical,
colourful "Code Sourcerer" button. It's a programming "wizard"
that will guide you through everything, right up to generating the code.
Okay here it is. A screenshot of the first application that I whipped up with
Simplicity. It's more than just a pretty face. All those drop down menus really
do work. Pressing "F1" really does bring up a simple help box, and those
checkboxes and text entry fields really do something. The only thing that doesn't
work is the Death Ray button, but I'm working on it. (Don't worry, the Extra Features
were removed before I released this particular application ;).
How much work was it? How much coding? I had to write a total of about 135 lines
of unnecessary code, the bulk of which are merely print statements and variable
assignments. That's it. Why unnecessary? Because I felt it was simply more efficient
to type in the code than go through Code Sourcerer. The point being, I didn't have
to write that much code, using Code Sourcerer, the number of lines of code would
be much less than 135 lines. Code Sourcerer does all the work for you.
And that's one of the great parts about this. Simplicity helps me along when
I need it. When I don't, I can discard it and jump right into the code and modify
it as appropriate, and pop back into the visual development environment when it's
Hey, nothing is ever perfect! During my little adventure, I did discover a few
annoyances which I should share with you, and I'll also make a few comments comparing
it with IBM Visual Age Java 3.0
My first gripe, the drop-down box used to select objects in the Composer window
appears to be sorted in order of object creation. That's fine when you've got a
small application with 10-15 objects, but with a large application, you really need
it sorted alphabetically! I've mentioned this to Data Representations, and they
agreed that it's a problem and would rectify that in the future.
A second minor annoyance is that you can't "drag 'n drop" items to
move them around in your application. For example, if you decide you really want
that Load button on the bottom and not the top, you can't just pick it up and move
it, even if you have room in your layout. The only way to accomplish this is to
"Recycle" this object, then go to the "Recycled" parts list,
pick it up and drop it off again in the new location.
Some of the layout items and objects are not "standard" Java, but are
extra objects created by Data Representations and packaged together with Simplicity.
These are really handy, but the catch is, the code for these are not included in
your generated code for your application. It's all in the .JAR file for
Simplicity. That's not a problem if you're running a server side application, but
if you're distributing it as a stand-alone application, it's a bit more hassle.
You're free to distribute it, according to Data Representations, but that means
that instead of an install script or instructions that just execute your Java application,
you'll also have to be sure that the extra .JAR file is included in the
appropriate paths or modify the users environment accordingly.
Now, this wouldn't be so bad if the standard items were segregated into obvious
groups, but it's not. All the items in Layout and Basic should be standard, but
a few of them aren't, so either dig through your Java documentation, or you'll have
to go by trial and error to figure out which ones are not. To their credit, I talked
to Data Representations, and they agreed that this might be a hassle, so they would
roll this change into some future release.
One of the more common trade offs, especially in software, is between ease of
use vs. power and flexibility. Simplicity really resides in the easy to use camp,
though of course, having access to the source code does make it as powerful as any
other development tool you could think of. But then again, if that's your inclination,
you'd probably be running EPM and not some sort of visual IDE. IBM's Visual Age
for Java (VAJ) is a competing product, sort of, and it tosses ease of use in favour
of a bit more power, in my opinion. It was my experience that it certainly was not
easy to get started with Java using VAJ, but was an absolute joy to learn in Simplicity.
However, having learned most of the basics and having learned to be "one with
the code", I found myself preferring VAJ over Simplicity for my more complicated
Just some brief notes about using Simplicity on Windows NT and OS/2. This comparison
is done on the same machine (the HP PIII-600), which uses Boot Manager to handle
switching between the two.
As noted previously, the installation on Windows NT is via InstallShield for
Java, which is much slicker than the OS/2 "unzip" install. However, the
InstallShield edition was much more problematic. The OS/2 install is easy
enough that anyone doing programming in Java should be able to follow without error.
I realize you could unzip it for Windows as well, but here is where the Java "integration"
with OS/2 saves you a few extra steps in setting up the startup .CMD file for Simplicity.
Thumbs up to OS/2 on this count.
When I first started using Simplicity, I actually preferred to use it under Windows
NT rather than OS/2, even though running it on OS/2 was noticeably faster to startup
and use. Why? Because of two very annoying bugs. One was a disappearing cursor in
the text editor windows. The second problem was a horribly annoying window flashing
everytime I moved any of the application windows. Both of these problems were IBM
acknowledged APAR's with the JVM on OS/2, and subsequent fixes have cleared up both
of these problems. So now, the only thing I have to say now is that Simplicity runs
equally well on OS/2 and Windows NT, but it's faster on OS/2. OS/2 wins both rounds!
On the PIII-600MHz machine, Simplicity was so fast it's hard to tell that it
wasn't a native application. On the PII-300MHz machine, Simplicity was still easily
usable for development, at least on OS/2. (And I did actually put together part
of the application on that particular machine, as it is my preferred laptop). The
P233MMX? Well, once it was loaded, it was still usable, but I think that's about
the lower end of what I would like to be using it on. If you have a really large
project or are running other jobs in the background, you might find it a bit too
slow to be really usable for long periods of time. That's really the JVM's "fault",
Simplicity is just about one of the better performing Java applications that I've
come across yet.
I had heard a few things about Simplicity, but didn't realize what the hype was
about until I actually tried it and went through the first tutorial. Words do not
accurately describe how it works. The trial version is a free download, so go get