AIS Project Proposals

Visualisation of Persistent Hyper-programs

Proposer : Quintin Cutts

Second Supervisor : Stephen Brewster

Summary: This project will investigate the increased application of hyper-programming within an integrated programming environment.

The hyper-program representation of code represents a radical divergence from traditional programming language concepts. This is because it can contain direct links to arbitrarily complex manifest values, such as records, arrays, procedures and abstract data types. Traditional languages only allow simple manifest values to be included in code, such as integers, strings and reals. The representation is of interest both statically and at run-time, as follows:

Any executable program is a complex graph of components made up of both code and data. Traditionally this is stored in a flat file, but in object systems it is held as a graph of objects in the object store. This graph can simply be represented using hyper-programming techniques - the nodes of the graph are code and other data objects, and the edges between these objects are the hyper-links. Since a program is just a graph, it can be simply manipulated within the programming environment.
Hyper-programs can also be used to represent executing programs. Most importantly, the constants and variables of the code being executed can be represented using hyper-links to the actual values currently in use.

A first prototype of the hyper-programming technique has been implemented. The aim of this project is to decide how it can be used to enhance the various processes within a programming environment. The move away from flat text-based program representations will require significant analysis of existing visual and sound based programming techniques, providing a strong link with the HCI branch of the course. Potential areas of application for hyper-programming include:

Debugging systems. The availability of the full state of an executing program within the context of a high-level programming language representation enables the construction of a powerful symbolic debugging tool. Not only may values be examined but they may be simply adjusted or else incorporated into further analysis and measurement tools.
Tracing systems. Since the entire program graph is available for manipulation, a tracing system using sonic or visual techniques may be developed that allows advanced interpretation of the execution of a program.
Configuration management. In software engineering terms, a configuration of a system is a representation of how the various components making up a large application are connected together. It is typically constructed before the software is assembled, and there is little or no support to check if the real configuration of the software matches the intended one. A program browser may walk over the hyper-program representation discovering the exact configuration of an assembled application, allowing the programmer to examine both intended and actual configurations. An open question here is exactly how the configurations are presented to the programmer.

There are undoubtedly other applications of hyper-programming within a programming environment. The aim of this project is to explore a number of different applications, including those above and perhaps some others, and then to design, implement and incorporate at least one of these applications into the existing programming environment.

References
Exploiting Persistent Linkage in Software Engineering Environments
Persistent Hyper-Programs
Reflection and Hyper-Programming in Persistent Programming Systems

Persistent Store Measurement and Visualisation

Proposer : Quintin Cutts

Second Supervisor : Stephen Brewster

Summary: This project will develop techniques to improve understanding of persistent system operation in order to lay foundations for the next generation of system implementations.

Populated persistent stores have reached a level of complexity beyond our understanding. The graphs of objects in which the programming language data structures are implemented can be reckoned with when considering one or two values, but when these graphs represent hundreds of thousands of values, there are currently few successful techniques for assessing them. In order to evaluate execution models and object management implementations accurately, it is essential that mechanisms are developed to clarify the complexity .

The aim of this project is to develop a number of store measurement and visualisation techniques enabling improved understanding of object store operation. These can operate both statically and during system execution. Use of these techniques will educate the development of the next generation of machine and storage architectures. Some potential research questions are:

What are the percentages of different kinds of values in the store. What proportion are procedures, type representations, locations, 'traditional' data structure, etc.?
How are the values spread through the store? Are connected values stored nearby one another? The aim is to gain some understanding of the general connectivity within the object graph.
How are values within the store accessed during execution? Are accesses clustered in one part of the store? Does the static layout match dynamic access patterns?

Because of the complexity of the data to be understood, the use and development of advanced representation techniques will be required in the project. This may involve visualisation or, particularly for run-time analysis, the use of sonic techniques. Sound is appropriate here since we can hear changing sounds faster than we can see changing images, by about an order of magnitude.

The work will be undertaken in the context of the Napier system, since stores of significant complexity have been built in that system. However, I am keen to make comparisons between Napier, a procedure-based language, and Pjava which as you all know is object-oriented. This is part of an ongoing effort with other researchers around the world to assess persistent system implementations and to find both general and paradigm-dependent measurement techniques and optimisations.

References
Work has been undertaken within this department, most recently by Peter Bailey and Tony Printezis and published internally, which primarily focusses on the execution behaviour of systems. Additionally, measurement of store behaviour was undertaken in previous years here and published in the FIDE research report series (FIDE 92/58, 93/71). Little other measurement work concerning orthogonally persistent systems is available.