Undergraduate Projects, 2016-17

AJHS-UG-1

Editor for Cloud Service Models

The goal of this project is to create a visual editor to capture the intended design of software services that will be deployed in the cloud. The intention is that the editor will be used as an attractive front-end for a set of quality assurance tools that have already been developed in the EU Framework 7 Broker@Cloud project. The editor will allow non-expert industry users to benefit from these tools; and a successful editor could be linked to some of these to show in a demonstration to industry.

A software service is a program that is deployed in the cloud and accessed via the Internet, using an API to send requests and receive responses. The design of a service may be thought of as an extended finite state machine (EFSM) whose states represent modes in which certain operations are possible, and whose transitions represent the operations of the service. Operations can have inputs and outputs; and they may also store and read values from memory, which is an arbitrary collection of program variables (the memory is what extends the power of a basic FSM). The FSM-part is best captured as a diagram showing states and transitions. The memory and operations are best captured as program-like text, with declarations for variables, signatures for operations, and a simple expression-language to capture boolean logic, arithmetic operations on numbers and simple functional operations upon sets, lists and maps, which are the only data types used.

The editor will be a visual tool, developed in Java. It will allow the designer to create state machines from a visual palette of icons, connectors and labels. It will allow the designer to enter text for memory declarations and operation declarations using a syntax-guided text editor with a simple parser behind it, which will check the syntax as it is entered and will construct the model in memory. The model will be constructed using a set of Java classes that were developed for Broker@Cloud. The model is already capable of of being serialized as XML, which is the storage format for models. This project is suitable for any student with excellent Java programming skills.

AJHS-UG-2

Code Generation for Cloud Services

The goal of this project is to generate working code for software services, to be deployed in the cloud, from model descriptions of these services. The project will use Java software tools developed for the EU Broker@Cloud project, which include the service models we will use, and a code-generation framework.

A software service can be thought of as a kind of extended finite state machine (EFSM). It exists in a number of states, in which subsets of its operations are enabled or disabled. The transitions of the state machine indicate how different service operations take the service from one state to the next state. Each operation possibly has inputs, outputs and also may have number of different branches, triggered by different conditions. An operation may also read or write to memory variables, which store extra information about the state of the service (memory is what extends the basic FSM). All of this is represented by an XML model specification language, which can be unmarshalled (parsed) as a strongly-typed Java tree, representing the service model.

The model has a code-generation interface that follows the Visitor Design Pattern for generating code. Whereas in the past, this has been used to generate tests to execute cloud services implemented by hand, in the current project, the aim is to generate the services directly from the models. To help you visualize what generated services should look like, there are several examples of services, implemented as "plain old Java objects" (POJOs) supplied as part of the existing software package. These examples follow the State Design Pattern, to represent a service in each of its states. Your task will be to generate as much of this as you can, from the model specification. If POJO generation is successful, then you may also attempt to generate the Java code for JAX-WS or JAX-RS web services, which each follow a different Java standard. Eventually, you may be able to specify a service model, then generate and deploy the working service to the cloud automatically. This project will suit any student with strong Java programming skills. Familiarity with Java EE will be useful.

AJHS-UG-3

Model-Driven Generation of Database Schemas

The goal of this project is to use model-driven engineering techniques to generate fully normalised database schemas from initial user requirements. The project will use Java tools developed for the ReMoDeL model-driven engineering project, which include structured models and transformation rules, both represented in Java. The models may also be marshalled as XML files.

Model-driven engineering (MDE) is the future of software engineering, in which you will no longer write detailed program code, but instead create more abstract models of software systems, which are automatically transformed into code. The supposition in MDE is that high-level requirements and design models may be forwards-engineered into executable systems. The challenge is to find and understand what kinds of abstract model are best suited to the forwards-engineering process. UML, for example, does not capture the right kinds of information: either it is too abstract to offer any useful handle on the detailed design, or it is so complex that you may as well have written the code. This project will use new kinds of high-level model, such as the Impact Model and the Property Model to represent how end-user actions affect the creation, updating and deletion of data. From these models, transformation rules will generate a fully-normalised database schema.

The approach followed will be to develop a Java representation of the Impact Model and Property Model within the ReMoDeL toolkit, then define Java transformation rules which construct a normalised Data Model by folding together different aspects from each of the input models. If the initial model-to-model transformation approach is completed successfully ahead of time, then it may also be possible to perform further model-transformations which generate the SQL statements to build the database, or generate Java code for a simple information system to manipulate the data stored in the database. This project is suitable for any student with excellent Java programming skills.

AJHS-UG-7

Abalone Board-Game Player

This project aims to develop a program to play the the strategy game Abalone, which is played on a hexagonal board. The two sides take it in turns to move pieces in any of the six possible directions, with the objective of eventually ejecting six of the opponent's pieces off the board. On each turn, one to three connected pieces may be moved. A broadside move may only be made, provided that there is space in which to move. An inline move may also be made, even if it is blocked by the opponent's pieces, so long as there are fewer of these opposing the moving pieces. Thus, three pieces may displace two; and two may displace one. A piece on the edge of the board may be ejected by such a move. It is recognised that a cluster of pieces, three wide in every direction, in the centre of the board is a very strong, defensible position; whereas pieces near the edge of the board are vulnerable.

The project will create a computer representation of the hexagonal grid, with a suitable coordinate system. It will investigate game theory and algorithmic notions of game playing, such as the mini-max algorithm for optimising zero-sum games. It will attempt to characterise what constitutes strong, or weak, playing positions on the board, such that a game search engine could seek to find the stronger positions for the autonomous player. The game playing engine should be built in software capable of rendering the playing field, for example, in Java and using the Swing toolkit. Suitable care should be paid to how the user should select the pieces to move, using a minimum of mouse clicks or object selections, and dragging the pieces to the new location.The notion is eventually that a human player could challenge the machine player, to see who wins the game.

AJHS-UG-8

Autonomous Spacecraft and Swarm Robots

This is the second of two projects offered in the area of spacecraft navigation, autonomous spacecraft and swarm robots. Spacecraft navigation is currently controlled from Earth stations, which send signals into deep space to alter the course or mission profile of the craft. However, this is only really effective over short ranges, because of the relativistic delay when transmitting over interplanetary distances. In the future, spacecraft should be able to make their own autonomous decisions about navigation and should be able to determine and evaluate their own goals.

The second scenario is the "Swarm Robot" example, where a group of robot satellites are released near a planet to engage in some kind of cooperative survey activity. The individual members of the swarm will share out different responsibilities, such as prospecting or reporting back, via a chain of robots, to the Earth station. In this scenario, you imagine that individual robots may become damaged to the extent that they cannot fulfil all their allocated tasks; and then you model how the remaining robots in the swarm reschedule their activity to complete the mission. This project will require developing a multi-agent model of the swarm, in a suitable multi-agent simulation environment. It should focus either on the Mars exploration scenario, or the asteroid belt mining scenario. This project may call upon (Timed) Process Calculi to model the concurrent execution behaviour of the robots in the swarm.