Programming language/tools

I am most interested in supervising projects that analyse programs. If you program a lot and have thought to yourself "If I had a editor/ide/code browser/debugger/tool/compiler/decompiler that could..." then it may provide the starting point for a project. Come and talk to me about it.

Using aspect-oriented programming for data visualisation

Aspect-oriented programming is a new type of programming usually built on top of object-oriented programming. It includes modular units called aspects with "cut across" the established class heirachy to add functionality to lots of different classes. The best place to find out about this is at aspectj.org.

This project would use aspects to provide data monitoring and visualisation as the program is running (basically providing a debugging functionality). Depending on how quickly you worked you could add different functionality to the system (i.e. simple: a table of values to certain variables to complex: graphical visualisation of linked lists and pointer related structures.

A data slicer

Program slicing is a new technique for visualising and understanding programs. It basically works by taking a program and an output value and returning the parts of the program that effect that output value (but nothing else), i.e. it focuses on the parts of the program that are relevant at that particular time.

This project would be a slight variation on the idea. It would take a program and an input, and a wanted output value and return the parts of the input that contributed to that final value. This could then be generalised in different ways.

A re-configurable code browser

I feel there may be some extensions to be made on the JQuery code browser: link. If you are interested in the idea of being able to define re-configurable "views" on code then come and see me, though we may have to do a bit of preliminary work to get to a nice project spec.

A language-aware diff

Diff is a program that examines differences between text files. It works by trying to spot changes in terms of added, removed or changed lines between files. It is quite useful for comparing two versions of a computer program to see what has changed.

Diff is not aware of the programming langauge though. For example, if I change one variable name in a program. It would return all the changes to every line of the program that use that variable.

This project would be to design and implement a language aware diff. It would try and take into account cases like the one above (just reporting the fact that one variable has changed). This project is extensible in lots of different ways depending on how many factors of the language you wish to take into account.

Tracing black-box program transformations

Program transformation systems come in many forms but basically have the same modus operandi: take a program in and feed a program (possibly in a different language) out.

Theorem proving for reasoning about game semantics

Reasoning about computer programs is difficult and one of the more interesting challenges in computer science. How do we know when one program is equivalent to another? or when a class of programs will or won't exhibit some particular behaviour?

The key to such questions is a well defined mathematical definition of what programs do. This is the semantics of a language. There are lots of ways of defining semantics but one of the more popular recent ones is in terms of game theory.

Theorem provers help us reason about these mathematical descriptions using computers. This project would be to try and use a theorem prover and see how well they can reason about programs using game semantics.

Animating program semantics

Operational semantics are a mathematical description of what a program does when it runs. Having semantics is a good thing since it add rigour and allows us to use mathematical, formal methods to reason about programs. Often semantics can be encoded in a descriptive logic programming language like prolog.

This project would take these mathematical descriptions and automatically create a graphical interpreter that visualises what happens when a program runs. There are several different levels on how this could be done and what could be visualised.

A functional language without ordered arguments

In standard ML, I may have written a function nth to get the nth element out of a list. I could have written it with type int * 'a list -> 'a list or with type 'a list * int -> 'a list i.e. the arguments could be taken either way round.

Is it possible to imagine a language where it did not matter what order the arguments were taken? So I would define nth once and then nth(2,[1,2,3]) and nth([1,2,3],2) would both evaluate to 3. In other words is it possible to have a language where argument order does not matter (if the arguments are different types).

This project would involve answering this question. It could focus on the type system for such a language (what are functional types now?, do types always make sense after we have applied several functions?) or on the implementation (how could we write an interpreter that runs programs in such a language?)