The goal of this project is to develop a suite of Java classes that will allow programmers to animate a variety of algorithms. The software produced should provide a basic graphical user interface that displays a flow chart of the algorithm to be animated, with controls for running through the entire algorithm or stepping line-by-line through the algorithm.
Particular animations would then be obtained by providing a flow chart and implementation for that algorithm, together with some graphical representation. Obviously, graphical representations will vary greatly from algorithm to algorithm, but the Java classes should be designed so that any representation could be incorporated easily. The project should provide some example animations, e.g., sorting algorithms or searching through linked lists.
Labelled transition systems give a very simple way of capturing the notion of process. Such a system consists of a set of states, and a relation between states and labels; for example, a : s -> s' means that the system can move from a state s to a state s' by means of a transition with label a, which can be thought of as some kind of action or event. Labelled transition systems can be composed in various ways by combining their states and transitions, possibly synchronising on certain transitions.
The language Maude allows transition systems to be implemented in a fairly straightforward way, and allows a user to step through possible sequences of transitions. However, it doesn't provide support for composing transition systems with synchronisation. The aim of this project is to design and implement a front end to Maude that allows the user to specify transition systems and to compose them by synchronising on transitions. The system should generate the Maude code to implement the resulting system and step through its possible transitions.
The aim of this project is to develop a website to help programmers who are learning Java to identify, and avoid, common programming errors. The website should incorporate a database of commonly occurring patterns of bugs in Java programs. Learning programmers would be able to submit a new pattern to be added to the database (as a proposal to be moderated by an administrator, rather than directly added to the database).
The database should be browsable. In addition, users should be able to search the database. This would be useful for programmers who have discovered that their code has a bug, but don't know where in their program it is, or how to correct it. The search mechanisms should be flexible enough to allow the tool to be used as a diagnostic aid.
The aim of this project is to develop an educational tool that gives a graphical representation of how systems of interacting objects can be created. The user inputs a simple program that creates one or more objects, possibly instantiating the fields of those objects. The tool executes the program step by step, and displays the objects that have been created, and the values of their fields. If the value of one object's field is another object, a graphical representation of this relationship should be given, perhaps along the lines of a UML diagram.
The aim of this project is to develop a tool that lets a user specify components of a system, then build the system by combining its components. The components would be specified in the language BOBJ, and the user should be able to load BOBJ specifications into the system, and specify how these components would be combined to construct a system. The tool would then generate the BOBJ code that specifies the composite system. The tool should be written in Java, and have a graphical user interface that displays the component specifications and the structure of the composite system, together with its specification.
Term rewriting is a form of computation where a term is simplified by repeatedly applying equations. Many languages, such as BOBJ, are based upon term rewriting. The aim of this project is to design and implement a program that acts as a front end to BOBJ, to present the user with a step-by-step reduction of a term; at each step, the program shows the user which equations may be applied to the term, and lets the user choose which equation is to be applied.
An important way of making new research publicly available is to present papers at conferences and workshops. Most conferences have home pages on the web, and are advertised through email and posters, and specify deadlines for submitting papers to the conference and the dates on which the conference is to be held. Researchers typically keep lists of forthcoming conferences, and from time to time will use a search engine such as Google to find more to add to the list.
The aim of this project is to develop a web-based front end to a database that maintains a list of forthcoming conferences and allows them to be browsed by date, deadline or topic. The user should be able to target specific conferences and include links to the latest version of a paper that they intend to submit to the conference. The tool should send reminders about upcoming deadlines for targeted conferences, and if a submitted paper has been accepted by a conference, a reminder should be sent for the date the conference is to take place. The tool should also provide assistance in searching for new conferences and adding them to the database by automating queries to selected search engines, and by filtering out conferences whose submission deadlines have passed.
The aim of this project is to develop software that allows a team to maintain, on the web, materials used in a collaborative project. Such materials could include software source code and executables, documentation in a variety of formats, diagrams and images, etc. Materials should be available to all members of the team at any time to browse through. However, it would be undesirable to have two team members modify an item at the same time. The tool should help prevent this by allowing only one team-member at a time to update any item. In addition, the tool should support basic version maintenance by archiving previous versions of all items.
This basic functionality could be extended in various useful ways: for example, material could be subdivided into sub-projects, with some items possibly being shared by different sub-projects; read- and write-permissions could be allocated to specific individuals or groups of individuals on the team; and messages could be sent among team members, perhaps concerning delivery deadlines.