Demonstration of Hyper-Programming in Java

Poster

Evangelos Zirintsis, Graham Kirby & Ron Morrison
School of Computer Science, University of St Andrews, Scotland

Hyper-Programming

Traditionally, programs are represented as linear sequences of text. Where a program accesses another object during its execution, such as another program or some data, the program contains a textual description of that object, describing how to locate the object. At some stage during the application building process that description is resolved to establish a link to the object itself. Usually this occurs after the program is written. There is no guarantee that a textual description of an object will remain valid until the time the object is used, even if the description is valid at the time that the program is written. In such systems programs are constructed and stored in some long-term storage facility, such as a file system, separate from the run-time environment which disappears at the end of each program execution.

In an orthogonally persistent system however, programs may be constructed and stored in the persistent store, the same environment as that in which they are executed. This means that the objects accessed by a program may already be available at the time that the program is composed. In this case direct links to the objects can be included in the program instead of textual descriptions. A program containing both text and links to objects, by analogy with hyper-text, is a hyper-program.

The diagram below shows an example hyper-program, comprising a class definition containing two links. The first is to a class, Person, while the second is to an object that is an instance of that class.

The use of hyper-programs has a number of potential advantages:

• Program succinctness: textual descriptions of the locations and types of persistent components used by the program may be replaced by simple embedded references.
• Increased execution efficiency: checking of the validity of specified access paths to other components is factored out when they are embedded directly in the source program. Checking of type consistency may be performed at compilation time rather than execution time.
• Reliable access to components: where a textual description of a component is replaced by a direct reference, the underlying referential integrity of the persistent object store ensures that the component will always be accessible by the program. By contrast, where a textual description is used it may become invalid by the time the program executes, even if it was valid at the time the program was constructed.
• Complete closure representations: it is possible to fully represent code fragments that refer to existing values within their closure. This is not possible with purely textual representations, since the identities of those values may be significant.

Demonstration Overview

The demonstration shows a prototype hyper-programming system based on the PJama persistent version of Java. An example of the user interface is shown below. It provides two main tools: an editor in which hyper-programs are composed, and an object/class browser that is used to locate persistent objects for linking. The browser is also used in conjunction with the editor for viewing hyper-programs: when the programmer clicks on a link in the editor, a representation of the corresponding linked entity is displayed in the browser. The top window shows a hyper-program under construction in the editor. The body of the main method contains links to a static method, Person.marry, and to two instances of class Person. The lower window shows the object browser, currently displaying details of one of the object instances in the left pane, and the object's class in the right pane.

By default, the editor displays hyper-links as textual labels. It is also possible to customise the display style on a per-object or per-class basis. The object/class browser can be similarly customised. Here is an example in which both editor and browser have been customised to display instances of classes Person and javax.swing.ImageIcon using appropriate bitmaps.

The following activities are illustrated during the demonstration:

• locating persistent objects using the object/class browser;
• composing a hyper-program, including inserting hyper-links;
• viewing the hyper-linked entities in a hyper-program using the object/class browser;
• compiling and executing a hyper-program;
• dynamic invocation of object methods using the object/class browser;
• customisation of the editor and object/class browser displays

Hyper-Code

Current research is directed at refining the concept of hyper-program to remove all distinctions between multiple program forms. The goal is to maximise simplicity for the programmer. A single, uniform, program representation is presented at all stages of the software process. Since this representation must be suitable for programs with closure, by implication it must be a form of hyper-program that can represent links to persistent values directly. To distinguish it from previous prototypes we refer to this representation as hyper-code.

The PJama hyper-program system falls short of this goal in several respects. Different representations are used for creating new values and browsing existing values: new values are created by writing hyper-program source definitions, while existing values are displayed graphically in the object/class browser. Secondly, full representations are not provided for all existing values, in particular it is not possible to view method source code.

The hyper-code system addresses these deficiencies by retaining all source code in the persistent store, and by providing the same single representation of values at all stages of the software process. As a consequence the distinction between editor and object browser disappears: all programmer interaction with the system takes place via a single unified hyper-code editor. This supports a small set of simple operations that can be composed orthogonally to achieve all programming activities:

• evaluate: this executes a selected fragment of hyper-code. If any result is produced this is returned as a further fragment of hyper-code.
• explode: this expands a selected fragment of hyper-code to show more detail, while retaining the identities of any values referred to.
• edit: this encompasses conventional editing facilities.

Implementation of this scheme in any particular language involves mapping the operations to the syntax of the language, and designing an appropriate hyper-code representation that can be used both to define new programs and represent existing values, in all possible cases. The example below shows a fragment of Java hyper-code containing several exploded links.

Further Information

The hyper-programming and hyper-code prototypes are freely available via the links below.

St Andrews Group:	http://www-ppg.dcs.st-and.ac.uk/
Hyper-Programming:	http://www-ppg.dcs.st-and.ac.uk/Research/HyperProgramming/
(Java system):	http://www-ppg.dcs.st-and.ac.uk/Research/HyperProgramming/Java/
Hyper-Code:	http://www-ppg.dcs.st-and.ac.uk/Research/HyperCode/
(Java system):	http://www-ppg.dcs.st-and.ac.uk/Research/HyperCode/Java/
PJama:	http://www.dcs.gla.ac.uk/pjama/

Email: {vangelis, graham, ron}@dcs.st-and.ac.uk