bjbjt+t+
PB\7aE
Samuel Watkins
Outline of a Project for the Summer Research Scholarship at SCHIL
Jade, an advanced development environment for the Java programming language
Introduction
During my first year of studies in Computer Science at Swinburne University, I was obliged to purchase and use a poor-quality Java development environment, Symantec Visual Caf
, in order to work on a number of substantial projects (as well as the assignments for my course).  This environment lacks innovations, and many its features are unreliable, poorly designed and painful to use.  Many other development environments, for various languages, suffer from similar deficiencies; even Borland Delphi, although it is perhaps the best of the popular environments, utilizes an almost entirely conventional text-editor for entering code, although many more powerful and flexible approaches were conceived and implemented decades ago.
As a result of my own experiences with Visual Caf
, and my observation of other students attempting to use it, I have become convinced that there is a great need for a well-designed, powerful, public-license Java environment.  Such an environment would greatly benefit students commencing studies in object-oriented programming, and would specifically support the software development subjects offered at Swinburne University.  In my view, object-oriented programming is the most difficult subject area for novice computer science students, and perhaps object-orientation is inappropriate subject material for an introductory subject; but such a subject certainly should not rely on an inadequate development environment.  For these reasons I have begun to design and implement an unusual development environment, which I am calling Jade (an acronym for Java Assisted Development Environment).  My primary intent is to design and implement a very high-level tool-set in support of students learning the Java language for the first time; a secondary intent is to provide functionality which will make the Java language more attractive to expert software engineers for the implementation of sophisticated projects.
Design
The architecture of Jade is not finalized at this point, however much of the conceptual design has been completed, and I will present some details of the environment
s novelty here.
Implementation Model
Perhaps the most important aspect of this design is the implementation model.  Jade is to be implemented in the Java language, which will make it compact, fast and portable.  Java is often considered to be less powerful than C++, and unsuitable for serious projects; this criticism is not entirely untrue, however many of Java
s problems can be avoided, and it has many advantages, such as true platform independence, that make it the language of choice for implementing Jade.  Many key aspects of Jade would be extremely difficult to code using any other programming language; a Java-based implementation facilitates introspective access to the class libraries, the implementation of a Java interpreter and shell, persistent object generation, and much else besides.
In order to achieve the best results from Java, I have decided to re-implement and modify some of the basic features provided by the standard class libraries, including data-structures, the graphical user interface and communications channels.  It is unfortunate that the original vision of Java has faded somewhat over the years, and that many aspects of the newest libraries leave much to be desired (the JFC/Swing GUI, for example, is an unwieldly abomination!).  By implementing my own reusable class libraries, I can ensure that Jade performs just as smoothly and rapidly as the best of the existing environments (that have been written in the faster languages, Delphi and C++).
Another crucial aspect of Jade
s implementation model is its open architecture.  In essence, open architecture means that every function offered to the user by Jade may also be accessed by means of events or method calls from another (Java) application; Jade is designed with a full application programmers
 interface, as if it were a class library (which, in fact, it is!).  Anyone who has used email and the internet would probably be aware of the pitfalls of closed-architecture design: most internet mail applications, and office suites, include an address-book function, but it is usually impossible to share one address-book among several client applications.  Hence the accumulation of a great profusion of address books, each supporting a different application, is inevitable.  Converting a data-file from one address book to another is a mundane task for a skilled Perl programmer, but it is an intractable problem for the average user (
Binary File Conversion for Dummies
 is not likely to feature among the best-sellers any time soon).  Another example of closed-architecture design is the language dictionary: a friend and I require a quality English dictionary package to support an AI project, but have been unable to find any software with an application programmers
 interface that we could use from our programs.  Clearly many applications would benefit from such a shared dictionary resource (we are developing one in Java).  By designing Jade with an open architecture, I can ensure that it will be easy to extend and customize, and that competent programmers may utilise every aspect of the system and its tool-set from other Java packages.  As the system will provide many highly useful functions, this last point will probably double the use-value of my project.
Jade will make use of many specialised Java features such as serialization, multi-threading and introspection, and will be implemented in a consistent and logical object-oriented style, with rich code documentation.  I have not yet determined which version of the Java Runtime Environment will be required to use Jade.
Functionality
Jade will provide a number of integrated but largely independent modules to support software development in Java.  The modules will be developed in series (incremental / evolutionary development), and the system
s open architecture will support the seamless integration of additional modules.
Modules currently under development include the following:
Low-Level Modules:
data-structures
The struct package will include fast and efficient symbol-tables, hash-tables, collections and trees.
flow-based programming
The flow package will contain standardised interfaces and classes for internal and I/O communications that support buffers, pipes, multiplexers, broadcasters, dynamic dis/connection, bi-directional communication, push-back functionality and relational flow-processing objects.
reflection / introspection
The reflect package will support signature enumeration, signature lookup, message referencing, aliasing and dynamic types (objects that can effectively progress from one class to another) for the Java language.
object persistency
The object package will support serialization, scripted initialization in Java, GUI construction support and object database management for the Java language.
Mid-Level Modules:
tokenization and parsing
The parse package will support tokenization and parsing, and the inverse operations. The system will be configurable by means of multiple language modules; a language module for Java will be included.
source-code auto-styling
The style package will automatically format source code into a particular coding style, including the automatic generation of appropriate comment stubs.  The system will be highly configurable by means of multiple style modules (including support for languages other than Java); style modules for Swinburne University
s Software Development Java coding style, and for Sun
s Java API code style will be included.
graphical user interface
The cui package is a fast and efficient, platform-independent visual layout and windowing toolkit, allowing multiple views on a single object, transformed co-ordinate systems, uniform treatment of all graphical entities (from font characters to containers), bi-directional association of graphical entities with semantic objects and clipping areas of irregular shape.  CUI is an acronym for Contextual User Interface.
High-Level Modules:
structured source code editor
The edit package will support different perspectives on a program, including standard text, hierarchically block-structured text, imbedded objects (e.g. equations) from other client editors and WYSIWYG pretty-printing.  The editor will represent a project consistently from the smallest components to the largest 
 in Java, from packages, classes, methods, statements, right down to tokens, identifiers and (unicode) characters.  The editor will have code tokenized and parsed as it is entered, and will support incremental compilation, execution and static checking, for example, as background tasks.  The editor will not be specifically designed for Java, but will support multiple language modules; a language module for Java will be included.
source code interpreter
The interpret package will implement a complete Java source code interpreter, including support for all class libraries, additional classes, applications and applets.  The interpreter will also facilitate the Java shell, profiling and testing of classes.
analytical tools
The analysis package will support static anaysis (including source-level optimisation), profiling and testing of source code and object code.
imperative shell
The shell package will collaborate with the Java interpreter to implement a multi-threaded, imperative shell.  Users may enter Java commands and see the results immediately, without any intermediate compilation phase.  The shell will support all Java functionality, including the declaration of classes and methods, although these commands require class files to be re/compiled.
mathematical notation editor
The math package will interface as a client to the structured editor, and allows the display and editing of mathematical formulae (and other Java expressions) using standard mathematical notation.
visual programming
The visual package will support visual programming, specifically the display, editing and animation of diagrams in various notations.  A visual syntax for Java will be developed to enable visual editing of all aspects of a Java program.  Algorithm animation, which is mainly useful for pedagogical purposes, will be an important aspect of the presentation system.  The package will support multiple notation modules; notation modules for COMN Light, OML and ASK (Abstract Symbolic Knowledge, a notation I am developing for visual programming) will be included.
Interfaces to Third-Party Modules:
s jikes compiler for Java
Jikes is a fast and free Java compiler, that will be used by Jade for compilation in preference to the standard javac (Sun
s Java compiler), which is very slow.
jasmin Java byte-code assembler
The possibility of using portable assembly-code may well open a new dimension in programming.  Jade will support in-line byte-code assembly, by means of the jasmin byte-code assembler.
s jar compression utility
Jade will use the standard jar archival utility to automatically render projects into a single file for ease of transport.  Jade will also be able to use other compression utilities to read and produce .tgz and .zip archives.
User Interface
The user interface used by Jade is called CUI, which stands for Contextual User Interface.  CUI is a new type of graphical user interface; the design focuses on versatility and simplicity, and eliminates the need for persistent buttons and widgets, which clutter up the displays of existing GUIs.  Unlike Java
s Swing/JFC GUI, CUI will use memory with restraint and will perform with great speed.  CUI uses a variety of gestures above and beyond the standard click / double-click / drag, and is highly suitable for use with stylus input devices.
CUI can use anti-aliased rendering for fonts and graphics, which improves legibility (it is quite possible to read 4 point anti-aliased type on a 15
 monitor).
The primary concept behind CUI is the uniform treatment of (multiple images of) entities, in a hierarchy from the highest to the lowest levels of layout 
 from characters and shapes through words, lines, paragraphs and icons to documents and containers.  CUI is called a 
contextual
 user interface because an event (usually from the mouse or keyboard) will be interpreted according to which entity is selected as the current context, and according to that entity
s activation state.
The best way to explain CUI would be to demonstrate its operation, but as is not fully implemented yet, I can only describe a simple use case from Jade (probably not fully representative of the final interface):
The User starts CUI:
The back display clears to a brown colour.  No further information appears on the screen.
The User drags with the left button.
This gesture creates a new container, visible as a borderless rectangle of light grey, and containing the black text 
System
 in a large font: this is the top of the system container.
The User drags with the left button from a point within the system container.
This gesture moves the system container smoothly within the display.
The User drags with the right button from a point within the system container.
This gesture resizes the system container smoothly within the display, keeping its centre fixed.
The User clicks with the left button on the system container.
The container opens, changing to a dark grey colour (the top is removed and the back is visible) and reveals the tops of smaller containers within it, each representing a Java package / package group.
The User drags with the left button from a point within the system container.
The display inside the container pans smoothly until the java package group is visible.
The User drags with the right button from a point within the system container.
The display inside the container zooms smoothly so that the information on the top of the java package group may be easily read.
The User clicks with the left button over the system container.
The container is activated; the user has entered the container.  The back of the container changes to a brown colour, and the back of the main display changes to a dark grey colour.  Now the User can manipulate the contents of the container.
The User double-clicks on the java package group with the left mouse button.
This gesture is a combination that opens and enters (activates) the java package group container.  The back of the system container changes to a dark grey colour, as it is no longer the current context, and the java package group container is opened and activated, appearing with a brown back.  The tops of containers representing the packages java.lang, java.io, etc. are visible.
The User disactivates the java package group container by clicking with the right mouse button.
Now the primary container becomes the current context again; the package group contents remain visible but cannot be manipulated while their parent container is inactive.
The User presses and holds the left button over the java package group.
The primary container zooms and pans so that the java package group fills its entire space.
The User releases the left button.
The java package group is activated, and becomes the current context. 
The User presses and holds the left button over the java.io package, then releases it.
The primary container zooms and pans so that the java.io package fills its entire space, and is activated.  Classes and interfaces are visible as sub-containers, with the signatures on the tops of the containers.
The User presses and holds the left button over the BufferedInputStream class, then releases it.
The primary container zooms to, opens and enters the BufferedInputStream class.  Documentation on the use of the class is shown, and methods and instance variables are visible as sub-containers, with the signatures on the tops of the containers.
The User presses the right arrow key a few times.
A marker moves through the gaps between the sub-containers, as a carat moves through text in a word-processor.
The User presses the up arrow, then the left arrow a few times.
The marker disappears and the tops of the sub-components, still closed, are highlighted in the reverse order with a light brown colour.
The User presses the up arrow when the readLine() method is highlighted, three times in succession (or once, holding CTRL).
The readLine() method is opened, then activated, then fitted to the primary container.  The source code comprising the readLine() method is visible, preceded by full documentation for the method
s use.  Blocks and statements appear as sub-containers, and are already open to reveal the tokens within, which are also containers (of letters and symbols).
The User (who is evidently working for Sun, perhaps I am being a little over-optimistic here!) can enter code and modify it using the mouse, arrow keys, backspace and delete as is customary, and of course the rest of the keyboard.  The only real difference is that the up and down arrow keys are used to change context levels, not to move vertically; the left and right arrows browse the entities or the gaps between entities at the current level.
I hope that the above simple use-case (which might take perhaps 10 seconds for a moderately experienced user to execute) gives a qualitative idea of CUI and its value as a user interface.  I realise that it is difficult to appreciate this without any illustrations or prototypes, but hopefully the idea is clearly represented never-the-less.
Conclusion
I feel that this project is a challenging (perhaps excessively challenging!) and worthwhile subject for research, and I fully intend to pursue it to the conclusion.  I have chosen a modular development model, so that I will be able to produce and demonstrate aspects of the Jade system progressively.  The project as outlined here is very ambitious, and I may not be able to complete it in the period of time designated, however I will certainly be able to implement many key aspects of the system.  I intend to finish modules for the user-interface (CUI), structured editor and interpretive shell, as a bare minimum, during my summer period at SCHIL.
E3?>
E3?>
Samuel Watkins
s1087037
Normal.dot
s1087037
Microsoft Word 8.0
Swinburne University
Samuel Watkins
Title
_PID_GUID
0@y7aE
5&SQ
My Briefca
0@y7aE
0@y7aE
My Briefcase
MYBRIE~1
Microsoft Word Document
MSWordDoc
Word.Document.8