VOICE Home Page: http://www.os2voice.org
June 2001

[Newsletter Index]
[Previous Page] [Next Page]
[Features Index]


Simplicity for Java

By: Isaac Leung ©May 2001

What is it?

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.

The Test Rig

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 machine:

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.

Let's Go!

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 :)

Startup Dialog

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.

Working with Simplicity

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

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.

ComposerObject Palette Layout

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.

Object Palette Basic

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.

Hard work

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.

Composer Listeners

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.

Composer Code

My First App!

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

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

What? No warts?

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

WinNT vs. OS/2 and performance

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.

In Conclusion

Simplicity for Java is a Java based rapid application development (RAD) tool for Java. It works exactly as advertised and is very, very easy to use even if you are not an experienced coder. At $149, it's not an impulse buy for your average user, but if you're a programmer or thinking about picking up programming, it's not bad. As I found out, it is so easy to use that you could almost consider it a self-guided course on learning to program in Java. If you think of it that way, $149 is a pretty sweet deal.

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 it!

Article references:
Manufacturer:Data Representations
Data Representations Logo
Price: $149 US (regular edition), $895 US (Professional edition)
Requirements: Any system with Java 1.1.8 JVM

[Previous Page ] [ Index] [Next Page ]
VOICE Home Page: http://www.os2voice.org