System Requirements
Asymetrix supports Windows NT 3.5.1 or 4.0, and Windows 95. You need a 486 66MHz or faster, and 32MB of memory. The software runs comfortably on my 32MB Windows 95 test system. According to System Monitor (a Microsoft tool), the allocated memory went from 18MB to 73MB after some standard operations. I opened a project (6 Java source files, 1 C++), built everything in it, and tried executing it and using the debugger. Although this does seem like a lot of memory, it is mostly virtual memory: the system was not swapping once it had paged out what I was not currently using. I was able to use Microsoft Word 7.0 and SuperCede on this system together without trouble.

Installation
Windows NT 3.5.1: I installed the software on a dual processor Pentium 90 with 128 MB of memory. The installation went as expected: a standard InstallShield.

Windows 95: I installed the software on a Pentium 166 with 32 MB of memory. The installation went as expected: a standard InstallShield.

Tool Components
IDE: The IDE resembles the Windows Explorer. There is a left-hand column showing the source files, class browser, etc. In the right-hand column the current editor selected appears: the Form Editor or the Source Editor.
Form Editor: The form editor allows the programmer to graphically lay out components on a form and to assign actions to the individual events. The Form Editor (see Figure 1) supports all of the layout managers as well as all of the standard AWT components. Asymetrix plans support for ActiveX components in early 1997.

Like all of the GUI layout tools that I have seen, there are some major weaknesses here. For instance, the Form Editor only understands standard AWT components. If you create any of your own components, it will not use them. The support for the GridBag layout manager is also weak; it did not work at all as I expected.
Source Editor: The source editor is pretty primitive by programming editor standards. Picture Window's Notepad with colors. There is no support for regular expressions. There do not seem to be keyboard accelerations for anything (other than cut and paste). It also does not do brace matching, a glaring omission. Support for automatic code indenting, or at least to indent/outdent a block would be handy.

The macros are pretty much useless since you can not save them to a file: they are for the current editing session of the current file only.

Class Browser: The class viewer is very slick, and an easy way to remember parameters, etc. (see Figure 2). The user can simply right-click over a member and go to it in the source. It has two go' options: Go To Definition and Go To Declaration. I assume this is only useful when doing native methods, because the definition and declaration are always the same thing in Java.
Compiler: The compiler here is definitely slower than, for instance, the Symantec one. However, the comparison may not be fair since the Asymetrix compiler is creating native code instead of byte-code. At any rate, the beta release document does mention that Asymetrix is working on this and that they will improve performance in the final version. The compiler is fast enough anyway, especially since the management of the dependencies required to do incremental compilation must cause a fair amount of overhead at compile time.

Performance
Asymetrix has run the CaffeineMark benchmark, as well as a number of other benchmarks, against their plug-in for Netscape Navigator. Their numbers indicate this compiler performs significantly better than a Just In Time compiler (JIT). For the performance numbers Asymetrix quotes, see Table 1. As you will note, there is not an across the board increase. Some performance aspects are slower than doing similar operations in either of these browsers. Also, the SuperCede Virtual Machine operates as a Plug-In, and you must change your HTML to use it. For a more complete analysis of performance, see http://www.cs.cmu.edu/~jch/java/benchmarks.html.

Features
The compiler has some interesting features, allowing the programmer to easily jump between C++ and Java. This makes the product attractive for anyone with a large investment in C++ classes, or anyone who requires direct access to WIN32 API calls.

This code fragment indicates the general idea. The two source files together will comprise the definition of the Java SortedIntegers class.

Listing 1: SortedIntegers.java
public class SortedIntegers
{
private int integers[];
public SortedIntegers( int n[])
{
sort(n, n.length);
}
public native void sort(int [], int);
}

Listing 2: SortedInts.cpp
#include "JavaNative.h"
void SortedIntegers::sort(int *n, int number )
{
qsort(n, number, sizeof(n[0]), IntCompare);
}

The C++ code has access to the Java data members, and vice versa. The compiler even includes limited support for catching C++ exceptions in Java (although it cannot map all of them).

Debugger
In my opinion, the SuperCede debugger is on a par with that of Symantec or Microsoft. The debugger has two features that are novel: the debugger scratch area (allowing evaluation of Java source code) and the POP command (allowing a method to be restarted). The debugger includes all of the standard features you would expect (stack view, watches, memory dump, etc.).

One aspect of the debugger which is well done is the data view. It is presented as a call stack in a selection pulldown, and then a Windows Explorer style tree view of the data. The user can double click on values to change them.

The SuperCede debugger does have one unique feature that, to my knowledge, no other tool has. The debugger scratch area allows the user to execute arbitrarily complex code without compiling it. When the debugger is in control, simply type statements into this area, and they will be evaluated in the context of the current method.

Omissions
There should be a separate view for threads. Although all currently running threads appear in a pulldown in the stack trace, it would be nice to have a tabular form of what is currently running, and the state of each thread. In a multi-threaded environment, it is quite important to be able to temporarily suspend a task or to see deadlocks.

Another important omission is the ability to set thread-specific breakpoints. I have often needed to debug a particular thread through a particular function. I could not find a way for an action-point (code that is executed on a breakpoint) to cause the debugger to continue. This is one of my favourite techniques for conditional breakpoints.

Weaknesses
The applet or application you are debugging freezes when you hit a breakpoint. This stops the screen of it from updating. Unless you have a large enough resolution monitor to have your test application completely unobscured, this means that you will be unable to see the graphical output of what you are debugging.

Exception support is weak, telling the user only that an exception occurred, and not the type (NullPointer, MalformedURL, etc.). Stack traces through C++ native methods (for instance, the SuperCede runtime) show as mangled names. For instance, the stack trace would show

java::lang::ThreadGroup::makeSystemdUIWYvGhbKp()

instead of

java::lang::ThreadGroup::makeSystem(Parameter type, Parameter type, ...)

Strengths
The use of tracepoints is a very nice way of implementing one of the oldest debugging techniques. It allows you to mark a statement just as you would a breakpoint. When run, these tracepoints print out to the log. You can then double-click on each one, and the source view will jump to that line. This allows for after the fact diagnosis of problems, and debugging of timing or order dependencies between threads.

The debugger scratch area is a nice idea: it allows you to execute Java code in the context of the method you are executing. The code can be arbitrarily complex, calling other methods, etc., or simple statement evaluation.

The POP command is an interesting (although not always useful) way to restart a method that has a bug in it: you edit the source code, update, POP the method and let it restart.

Documentation
The quality of the documentation impressed me, particularly considering that this is beta software and the development team probably has their hands full keeping their own documentation up to date. I found the manual style to be very clear and uncluttered, a refreshing change from some technical manuals with many different fonts and images replacing content. However, Asymetrix should include the Java language and class library documentation, and not just bring up Netscape Navigator to the Javasoft site.

One thing was irritating about the documentation: they provide half of it in Microsoft Word and half in Adobe Acrobat Portable Document Format (PDF). The documentation should all be in the same format (preferably PDF since the reader is freely available).

Notable omissions from the manual were:

Ease of Use
Generally, I liked the user interface of this product. It has two main windows, which I found a little strange, never knowing which menu bar to go to (I would have rolled the two windows into one).

Another small problem is in the properties: you can select some special characters (for instance, end of line). However, you specify these in ASCII (decimal). This makes it pretty tough to tell what you are going to get.

The Windows-Explorer class view in the browser requires double clicks to expand, instead of the single clicks required in the Explorer. I found this a little confusing, and was constantly single clicking on it.

Quality
The overall quality of this beta release was very good, boding well for the released version. The release notes were thorough (there is nothing more irritating than having to trip on all the problems yourself only to have technical support say that it is a known problem).

Support
Asymetrix has a full range of support options for the user. They offer support through:

I submitted my support requests through the form on their Web page. In particular, for telephone support they have numbers to call for Australia and Asia, Europe as a whole, France, the UK, Germany and the U.S.

Overall Impressions
I liked this product. I felt that the weaknesses were acceptable for a version 1.0 product, and that the promise it showed was good. SuperCede has enough novel features (native compiler, support for native methods, persistent memory, on-the-fly compilation) to make it well worth using.

I would like to see Asymetrix concentrate (for a future release) on better class and source browsing, source code control, and better support for Applets.

I think SuperCede is the best development package I have seen so far for creating Windows applications in Java. It does not address, however, any of the cross-platform ability of Java. Hopefully, the released version will support creation of Java byte code.

Availability
You can obtain the beta version free of charge from the Asymetrix web site (http://www.asymetrix.com). Asymetrix planned to release SuperCede late in 1996, with ActiveX support planned for the first quarter of 1997.