Renata Project: Student project list

Renata Research Project, Computer Science, VUW

Graduate Student Project Ideas, 1999

Robert Biddle and Ewan Tempero

• Run-Time Support for Developing Reusable Components

[1 current project underway by Stuart Marshall, for MSc]

Many aspects of program development and understanding involve the dynamic behaviour of the program. In order to develop or use program components, it is often important to experience the dynamic aspects of the components, whether for testing, debugging, or familiarisation. This project is to explore how this can be supported within a programming environment. For example, in an OO system, it might be useful to facilitate testing of components by creating objects, and then calling methods, specifying parameters by filling in a form. Understanding of dynamic behaviour might be supported by automatic creation of diagrams tracing program execution through different components, or by automatic connection of the code to a program visualisation system. (This topic was also the basis of the 1997 MSc thesis of John Miller-Williams, and the 1995 PhD thesis of James Noble. The earlier work will form the starting-point of this new project, and facilitate further research and development of these ideas.)

• A GUI Builder to Support Reuse

Graphical User Interfaces (GUIs) can make programs easy to use, but they themselves are often surprisingly difficult to create. The technology can be applied to itself, and systems like Visual Basic use a GUI approach to creating other GUIs. However, this kind of software often does not scale up, and does not easily allow reuse of GUI elements from previously written software. This project is to explore these issues, by creating and testing a small GUI-based GUI creation tool where the components can easily be reused for many different programs.

• OODB Support for Program Testing

[This project developed in cooperation with Gill Dobbie and Cameron Kay.]

Testing of programs can be part of the debugging process during development, or part of a validation process later on. In both cases, one of the difficulties is organising and controlling program input and output. Better support for this process would assist both in creating reusable program components, and in later reuse of components. This project is to explore how testing of OO programs might be supported by use of an OO database. The main idea is to use the database to store test data, and to allow input, browsing, and selection of particular test cases. However, the approach might lead to a different general model of program input and output that could further, simplify the whole programming process.

• Supporting Use of OO Frameworks

[1 current project underway for MSc by Vishnu Ande]

An OO framework is the skeleton of an OO program for a particular kind of application, providing minimal functionality and communication between the components. Programmers use such frameworks by providing detail implementations of the component parts, thereby customising the framework for a particular purpose. However, programmers often find use of frameworks more difficult than they expect. In particular, it is difficult to understand how to make the detail components fit in to the framework, and to understand what is happening when things go wrong. This project is to explore ways of supporting the users of frameworks. Possible approaches would include design of tools to assist framework users, design guidelines for frameworks themselves, and methods of providing the kind of documentation appropriate for framework users.

• A Browser to Support Reuse

A browser is a software tool that allows the programmer to inspect their program by navigating between related parts of the code. For example, many OO CASE tools include a class browser that allows the user to inspect the fields and methods of one class, and then move on to the classes used in those fields and methods. This project is to explore how such browsers could better support understanding of reuse issues in program development. (This topic was also the basis of the 1997 MSc thesis of Eduard Vaks. The earlier work will form the starting-point of this new project, and facilitate further research and development of these ideas.)

• Text Editor Support for Reuse

Despite many sophisticated attempts to support code reuse, one of the most heavily used tools is also one of the most primitive: the text editor. Programmers are always using text-editors to copy code from one program to another, and then to adapt the code to the new situation. This project is to explore how these processes could be better supported. One approach might be to automatically detect dependencies between code assemblies, so that programmers using cut-and-paste operations were more aware of problems that might occur. Another approach might be to provide explicit support for adapting code in specific ways: changing the names of variables, deleting blocks of related code, etc.

• Making Wizards Smarter

[1 Project under consideration by Geoff Copeland]

A "wizard" is program that helps the user do some task by means of asking a series of questions, and inferring what needs to be done. In particular, wizards are sometimes used to help programmers create complex programs. The wizard asks questions, the user responds, and the wizard generates the code for the program including many calls to libraries. The user then takes over the programming, completing the code and customising it where necessary. However, the approach has several drawbacks. For example, programmers have to work with and around code they do not understand, and it is difficult to know how this code can be modified or augmented. Moreover, if the programmer later changes their mind about some of the answers given to the wizard, they often have to start all over again -- they will have lost the work they have done on the code. This project is to explore ways of addressing such problems by making the wizard approach better support the needs of programmers.

• Project Configuration Support

Project configuration software allows programmers to specify the units of code that are component parts of a single project or program. The software can then be used to navigate the program, keep track of changes in code, and facilitate automatic re-compilation etc. This project is to explore how project configuration software could better support programming with reusable components. One idea is to support abstract interfaces in project configuration, so that components themselves refer only to interfaces, and the configuration software is then used to connect interfaces with implementations. Another idea is to use concepts from Software Architecture in the design of a program configuration system, so that a programmer begins with an architectural layout of their program, and uses the configuration system to identify how individual components will connect together. These ideas also relate to version control, whereby different versions of components could be specified using the configuration software.

• Web-based Code Repositories

A code repository is a kind of database for reusable code. The repository supports code providers by making it easy to associate documentation with the code, to group related code together, and so on. Code users are supported by making it easy to find and retrieve useful code. In the past, code repositories have often been cumbersome and too difficult for both code providers and code users. This project is to explore making a code repository easier to use, by leveraging ideas from the web, and from web browsers.

• Supporting Code Exemplars

An exemplar is a model that you can follow to do something. We make exemplar code when we teach programming, and when we document how to use libraries. Students and library users then use this exemplar code when writing their own programs. They often start with the code exactly as suggested, and then later modify it to meet their requirements. This project is to explore how to support this process. For example, difficulties sometimes arise because it is not clear which parts of an exemplar are compulsory, and which are customisable. A special text-editor might support exemplars as a kind of template, where some code cannot be changed, and other parts can. Documentation of exemplars could also be supported by using a similar approach.

• Visualisation as Documentation

It is often difficult to know how to use library code because it is not clear what the code does, or how it really works. Explaining what code does and how it works is a job for documentation. However, textual documentation is often very hard to understand. As an alternative, documentation could be provided by program visualisation, where animated diagrams show pictorially how the code works. Such visualisation could be interactive, and allow the user to explore use of the code in order to determine whether it is suitable for their purpose, and how best to use it. This project is to explore this idea by creating visualisations as documentation, and testing to see whether they really do help in practice.