-
Supervisor:
Monika Solanki (ms491)
Prerequisites
Knowledge of graph traversal algorithms
Aims of Project
The aim of this project is to implement a flight scheduler using Dijkstra's algorithm for finding the shortest path
Suppose you are given a timetable which consists of a set A of n airports, and for each airport a in A, a minimum connection time c(a).
A set F of m flights and the following for each flight f in F
- Origin airport a1(f) in A
- Destination airport a2(f) in A
- Departure time t1(f)
- Arrival time t2(f)
The main objective is to design an efficient algorithm for the flight scheduling problem. There are two airports a and b and a time t. the algorithm should compute the the sequence of flights that allows one to arrive at the earliest possible time in b when departing from a at or after time t. Minimum connecting time at intermediate airports should be observed.
Challenges presented by the project
problem analysis, graph traversal algorithms, implementation
Learning Outcomes
understanding Dijkstra's algorithm for finding the shortest path, Understanding general graph traversal algorithms, implementing the algorithms
Nature of End-Product
An implementation of Dijkstra's algorithm for finding the shortest path
Project Timetable
Semester1
Understanding background material, pseudo code for the algorithm,
Semester2
implemented algorithm
References
- Data Structures and Algorithms in Java,Michael T. Goodrich and Roberto Tamassia.
-
Supervisor:
Alexander Kurz (ak155)
Prerequisites
CO2014. Good programming skills.
Aims of Project
SWI-Prolog provides a command `trace' that allows to trace the execution of a goal. The aim of the project is to write a program that converts the output of `trace' into an SLD-tree. There should also be a graphical user interface that enables the use of SLD-trees for the debugging of Prolog programs.
Challenges presented by the project
Deeper understanding of logic programming, debugging and testing.
Learning Outcomes
Deeper understanding of logic programming, debugging and testing.
Nature of End-Product
A basic Prolog debugger.
Project Timetable
Semester1
Understanding how to draw trees and how to transform the output of trace. Design of the system.
Semester2
Implementation.
References
-
Supervisor:
Roy Crole (rlc3)
Prerequisites
Ability to programme in Java, C++ or a similar langauge.
Aims of Project
The aim is to write a computer program that can play scrabble against a human player, and perhaps against other machines.
Challenges presented by the project
The key challenges are to understand suitable game playing algorithms; and methods of dictionary storage. This will require some algorithms theory, and some simple automata minimalisation (for the dictionary). The GUI will also require careful thought if it is to be a good one. Note that although many people can produce adequate players, implementing one of high quality is not as easy as one might think.
Learning Outcomes
- You will understand the game of scrabble in detail.
- You will be able to describe, and code, efficient game playing algorithms.
- You will be able to describe, and code, efficient dictionary storage and access systems.
- You will be able to produce good GUIs for this and similar games.
Nature of End-Product
A computer program that can play scrabble, with a very good user interface, and efficient playing strategy.
Project Timetable
Semester1
literature and product survey; understanding and selection of playing algorithms; research into dictionaries; a prototype system which can play a very simplified game of scrabble; specification and design of the final system.
Semester2
Completion of design; implementation of game; simple user manual; final report.
References
- .
- . . References can be obtained from Dr.~Roy~Crole.
-
Supervisor:
Roy Crole (rlc3)
Prerequisites
This project requires familiarity with the module CO2008. It is also essential that you enjoyed the logic which you studied in CO1011.
Aims of Project
A theorem prover is a program which enables theorems (often of some logical system) to be derived in a (semi) automated fashion. Theorem provers have been used to study problems in mathematics, and for the verification of both hardware and software systems. This project will give you a chance to design and implement a simple theorem prover.
Challenges presented by the project
The key challenge is to understand how a theorem prover works in theory, and the principles of implementing a prover. Once the key software structures of a theorem prover are understood, one can fairly rapidly build one that is reasonably powerful. Many stages of this project are technically challenging.
Learning Outcomes
- To give an account of a simple logic;
- a coding of the logic's syntax in Haskell or ML;
- implementation of a simple theorem prover for the logic;
- design and implementation of a GUI for the theorem prover.
Nature of End-Product
A software system which has as inputs statements in a logic, and outputs formal proofs of these statements (whenever the statement is a theorem of the logic.)
Project Timetable
Semester1
Review of logics; studying the principals of simple theorem provers; specifying and designing a theorem prover; initial coding.
Semester2
Completion of the coding; construction of an interface; project write up.
References
- L. Paulson.
- ML for the Working Programmer (Second Edition). Cambridge University Press (1999). Further references can be obtained from Dr.~Crole.
-
Supervisor:
Roy Crole (rlc3)
Prerequisites
Knowledge of a high level programming language (functional or object oriented), and of simple details of a microprocessor, such as that found in CO1016.
Aims of Project
This project will involve the development of a simple simulator for basic microprocessors, using either a functional language or an object oriented language. Simulations for both register and stack based machines could be developed, along with a suitable front end GUI. The purpose of the project is to develop a tool which could be used for teaching simple computer architecture.
Challenges presented by the project
The key challenge here is to decide on a suitable approach to this project. There are many choices for simple instruction sets, many ways to parse in the instructions, many ways to display the animated processor and so on. Once your approaches to the components are made, progressing the project should be reasonably smooth.
Learning Outcomes
The outcomes will consist of some or all of the following, but will not be restricted to the list below which is to act as a guide
- A description of a simple model processor (ISA) at a very high level;
- specification and design of a model, using either objects or functions;
- implementation of the model; and
- design and implementation of a GUI.
Nature of End-Product
A GUI based software system, which will take a simple assembly language program as input, and run the program (simulate its execution) on an interpreter model of a CPU. The program execution will be visually traced, and processor statistics will be displayed.
Project Timetable
Semester1
Review the ideas of microprocessors and simple assembler. Conduct a literature survey. Specify a simple processor and instruction set, followed by a detailed design.
Semester2
Begin coding the simulator, modifying the design if need be. Construct a GUI. Complete a project dissertation.
References
- Steve Hill.
- The Functional Simulation of a Simple Microprocessor. Unpublished report (1994).
-
Supervisor:
Monika Solanki (ms491)
Prerequisites
Knowledge of programming web based applications, programming distributed systems
Aims of Project
The objective of this project is to develop a web based pay-as-you-go cyber cafe management system. The system should provide the following functionality
- The capability to record the time spent on internet usage for every machine in the cyber cafe.
- Once a user is logged into the computer, the system should be able to trace every site visited by the user.
- A billing system that presents the user with the amount to be paid, once the user logs out. The bill should include the exact times the user connected and disconnected.
- Maintaining a database of all internet usage for a customer
Challenges presented by the project
connecting the server to the different client machines in the cyber cafe, designing a web based user interface
Learning Outcomes
Knowledge of building real time web based applications and user interfaces
Nature of End-Product
A web based cyber cafe management system.
Project Timetable
Semester1
Understanding the development of web based application, developing prototypes and interfaces
Semester2
The complete implementation system and report
References
- Articles and Books on developing web based applications.
-
Supervisor:
Stuart Kerrigan (sk223)
Prerequisites
Graphic and image processing skills, some mathematics, good programming skills
Aims of Project
Active Contour, also called Snakes, is a framework for delineating an object outline from a possibly noisy 2D image.
Given an initial starting shape and positon on an image contour changes shape (deforms) until it reaches a state of convergance. This model is highly popular in Computer Vision, and led to several developments in 2D and 3D.
To illustrate, here is an Active Contour given an initial position and shape on a heart magnetic resonance image (MRI) scan. It converges to successfully find the heart.
Your task for this project would be to implement an Active Contour and apply it to a real life dataset of images.
Challenges presented by the project
- Familiarising oneself with Active Contour literature - good practice for a student considering a career in research
- Familiarisation with dataset
Learning Outcomes
- Computer Vision
- 2D image manipulation
- Research skills
Nature of End-Product
A software tool to allow use of Active Contour on a user-selected image.
Project Timetable
Semester1
- Reading of background material.
- Prototype
Semester2
Completed project + report.
References
- Andrew Blake and Michael Isard.
- Active Contours. (2000). Available online at author website
-
Supervisor:
Michael Hoffmann (mh55)
Prerequisites
Good programming skills in either Java or C++.
Aims of Project
Consider following the situation:
There are two people, each of them has a collection of different colored balls. For example person A has 2 red, 1 yellow and 1 blue ball. Also each person has an objective of what selection of colored balls he/she would like achieve.
The two people can now start to negotiate. Offering 2 red balls for a yellow one and so on....
The negotiation will take place, some balls get exchanged, until either a certain time is up or both people don't want to trade any more.
For just two people this situation can be already tricky, but now imagine a whole network of these people (Agents). Each agents a selection of colored balls and an individual objective selection that they would like to achieve. The network structure restricts the communication between agents to only the ones that are linked together.
The negotiation of making and accepting offers is no longer done by people but by computer programs for each agent.
The aim of this project is to create a computer program that allows the simulation of such a scenario.
The basic features of the product would be to handle different networks, starting selection, objectives of each agent and different computer programs controlling different agents.
Challenges presented by the project
The challenges in the project lie in
- defining and implementing a protocol on negotiation and trading between agents
- Creating and handling of graph structures
- Write your own agent controlling programs
- Analyzing and evaluating different agent controlling programs
Learning Outcomes
The student will learn about multi agents programs, the communications between them and agent programming strategies.
Nature of End-Product
The end product is a mulit agent negotiation simulator. It is based on agents are located on nodes of a graph (network. The agent trade different colored balls.
Project Timetable
Semester1
- Analyzing skill needed to complete the project
- Gaining/testing these skills by proto typing in a two agent scenario
- Establish the communication protocol between the agents
- Implement simple agents programs
Semester2
- Extend to multiple agent
- Position the agent in a graph
- Implement more agents programs
- Analyze your finding
References
- .
- . (1901).
-
Supervisor:
Michael Hoffmann (mh55)
Prerequisites
Good understanding of algorithm. Good programming skills in either Java or C++.
Aims of Project
Most algorithmic problems assume that the precise input is known. However in reality the initial information might not be precise and with additional cost the exact data for a certain input can be obtained.
Example (not so realistic, but explains the point): You take a taxi to let say 6 locations in Leicestershire. In order to save time and money you want to minimize the route. For each address the house number, street name and area is give. (e.g. 1 ...Rd City Center, 23 ... Drives Oadby, .....) In order to find the shortest route to all places the prices location of all addresses might not be needed, the rough area of these addresses could be enough. So an algorithm in this example would take the rough areas as the initial input. Then it checks whether or not the shortest route can be calculated, if not requests the exact location of some addresses until the shortest route can be calculated. So with least number of precise location lookups we give our taxi the correct order of addresses to minimize the journey.
The aim of this project is to design and implement algorithms for problems with areas of uncertainty and to evaluate them in systematic simulation experiments. Some algorithms have been proposed in the literature. In addition, there is opportunity to modify/improve the known algorithms or to develop new ones.
Challenges presented by the project
The challenges of this project can be found in the following areas
- Understanding the description of algorithms with uncertainty from the literature, and implementing them properly.
- Inventing new algorithms with uncertainty.
- Implementation and visualization of efficient algorithms
Learning Outcomes
The student will:
- Be able to discuss the application background of problems with uncertainty.
- Be able to compare different algorithm for a problem with uncertainty.
- Design a tool for simulating different algorithm for problems with uncertainty.
Nature of End-Product
A software tool to visualize and analyze algorithm with uncertainty.
Project Timetable
Semester1
Reading of background material.
Selection of the particular problem with uncertainty
Prototype for visualization of algorithms for the selected problem.
Semester2
Implementing known algorithm.
Design and implement new algorithm.
References
-
Supervisor:
Artur Boronat (ab373)
Prerequisites
A good understanding of OO-programming.
Aims of Project
Model-driven engineeringis a successor paradigm of object-oriented programming, where models are collections of objects that represent software artifacts, such as java programs, relational schemas in databases, UML models (class diagrams, activity diagrams...), etc. Models play a crucial role in a software development process since they are used to design the requirements of an application enhancing automatic code generation, increasing productivity and reducing costs. Therefore, providing mechanisms to guarantee that models are correct with regard application requirements are important. In this project, the student will learn model-driven development techniques based on theEclipse Modeling Frameworkto define models and to verify the correctness of requirements with the Object Constraint Language (OCL). The aim of the project is to build an application in Eclipse that reuses libraries for defining EMF models and for evaluating OCL queries.
Challenges presented by the project
The challenges of this project can be found in the following areas:
- metamodelling techniques for defining modelling languages (metamodels) and models
- use of EMF and OCL
- develop an application that enables the validation of requirements over EMF models
Learning Outcomes
The student will learn:
- to specify the requirements of an application, to design a system, to develop an application and to test it
- model-driven development techniques and tools: EMF, OCL
- development of Eclipse plug-ins
- techniques for checking the correctness of software artifacts
Nature of End-Product
Eclipse plugin that provides an interface for checking OCL constraints and for querying EMF models.
Project Timetable
Semester1
- Study of model-driven development techniques: EMF and OCL
- Specification, design and development of an initial prototype for checking OCL invariants over EMF models in a generic way
Semester2
- Development of an application for verifying models with OCL constraints and for reporting errors
- Development of a user-friendly interface for evaluating OCL constraints over EMF models
- Development of a user-friendly interface for querying OCL constraints over EMF models
- Specification, design and development of a complete prototype for checking OCL invariants over EMF models
References
-
Supervisor:
Roy Crole (rlc3)
Prerequisites
Knowledge of the basic construction of a modern computer processor, and in particular some acquaintance with the idea of cache memory. Familiarity with simple binary arithmetic. Proficiency with a modern object-oriented or functional programming language.
Aims of Project
A modern computer utilizes a cache. This is an area of memory "positioned" between the CPU and the main memory. The idea is that the CPU memory is small but fast, whereas main memory is large but slow. This leads to potential inefficiencies in the organization of data flow between CPU and memory, and the cache is used to alleviate these problems. The aim of the project is to understand how cache systems work, and then to design and implement a GUI based cache animator.
Challenges presented by the project
There are a variety of different cache models, and some are quite intricate. It will be a challenge to understand the key aspects of some models, and to understand them well enough in order to be able to animate them on a computer.
Learning Outcomes
These will consist of some or all of
- Knowledge and written account of the theory of computer caches
- Specification, design and implementation of a software package for the animation of computer cache circuits and algorithms
- A library of test examples and calculations
Nature of End-Product
A software package which will yield animation of cache circuits and their associated algorithms for efficient memory use. The system will have a user friendly graphical user interface, and will allow the user to select different cache designs and algorithms, providing the user with a graphical illustration of how the cache systems work.
Project Timetable
Semester1
Research and background reading into computer cache history; research into modern circuits and algorithms; the specification, design and implementation of very simple circuits and algorithms for cache management
Semester2
the specification, design and implementation of advanced circuits and algorithms for cache management; testing and documentation for the system
References
- W. Stallings.
- Computer Organization and Architecture (Sixth Edition). Prentice Hall (2003). Further references can be obtained from Dr. R. L. Crole
-
Supervisor:
Roy Crole (rlc3)
Prerequisites
Knowledge of the basic construction of a modern computer processor, and in particular the functions of an Arithmetic Logic Unit. Familiarity with very simple binary arithmetic. Proficiency with a modern object-oriented or functional programming language. An interest in algorithms for arithmetic.
Aims of Project
Although the addition and subtraction of binary integers is quite straightforward, multiplication and division are more complicated. Further, efficient implementations of each of these operations requires some care. If one also considers floating point arithmetic, then the issues become even more involved. This project will require some background research into the history of computer arithmetic, followed by the design of computer software which will provide graphical animations of the circuits and/or algorithms used in modern computer arithmetic.
Challenges presented by the project
At first sight this is an easy project. This is true of some aspects. However, there is a lot to be done, for example as well as integers, one can consider floating point numbers, and most importantly the algorithms for multiplication and division are fairly involved. Students must understand two or three such, and then implement on of them, perhaps outling the theory of the remaining one or two.
Learning Outcomes
These will consist of some or all of
- Knowledge and written account of the history of computer arithmetic
- Knowledge and written account of the theory of computer (digital/binary) arithmetic
- Specification, design and implementation of a software package for the animation of computer arithmetic circuits and algorithms
- A library of test examples and calculations
Nature of End-Product
A software package which will yield animation of digital circuits and their associated algorithms for computing basic arithmetic. The system will have a user friendly graphical user interface, and will allow the user to select different circuit designs and algorithms, followed by the input of test calculations whose execution details will be displayed on the screen.
Project Timetable
Semester1
Research and background reading into computer arithmetic history; research into modern circuits and algorithms; the specification, design and implementation of very simple circuits and algorithms for arithmetic
Semester2
the specification, design and implementation of advanced circuits and algorithms for arithmetic, such as floating point; the creation of a library of test examples; testing and documentation for the system
References
- Hennessy and Patterson.
- Computer Organization and Design. (Third edition.). Morgan Kaufmann (2003?). Further references can be obtained from Dr. R. L. Crole
-
Supervisor:
Shengxiang Yang (sy11)
Prerequisites
The project will involve a substantial amount of programming involving Algorithms and Data Structures. This should be in a object oriented style so students must have studied CO1005, CO2004 and CO2005.
Aims of Project
Evolutionary algorithms (EAs) are a class of problem solving algorithms based on principles drawn from natural evolution, such as nature selection and heredity. EAs maintain a population of candidate solutions to a given problem which are evaluated according to a problem-specific fitness function that defines the environment for the evolution. New population is created by selecting relatively fit members of the present population and recombining them through genetic operations using various genetic operators. Due to EA's characteristics of easy-to-use, great robustness and good parallel processing capacity, it has been used in a great number of scientific and engineering problems and models, such as numerical function optimization, combinatorial optimization (e.g., the knapsack problem, the job-shop scheduling problem, and the traveling salesman problem), automatic programming, machine learning, economics, and finance analysis.
The aim of this project is to design and implement a simple software package to demostrate and animate the process of using Evolutionary Algorithms for problem solving in either C++ or Java.
Challenges presented by the project
The potential challenges of this project are listed as follows:
- Understanding the key concepts of evolutionary algorithms
- Implementing evolutionary algorithms to solve selected optimization problems in C++ or Java
Learning Outcomes
- Learn about algorithm engineering.
- Learn about Evolutionary Algorithms.
- Implement Evolutionary Algorithms for solving some optimization problem.
- Build a simple software package.
Nature of End-Product
A practical software package for animating the Evolutionary Algorithm problem solving process.
Project Timetable
Semester1
Research on Evolutionary Algorithms and typical test problems, algorithm engineering, design of algorithms and package.
Semester2
Implement and test the algorithms, finish the project report.
References
- D. E. Goldberg.
- Genetic Algorithms in Searching, Optimization and Machine Learning. Addison-Wesley, Reading, MA (1989).
- Zbigniew Michalewicz.
- Genetic Algorithms + Data Structures = Evolution Programs. Springer-Verlag (1999). (3rd edition)
- Thomas H. Cormen, Charles E. Leiserson and Ronald L. Riverst.
- Introduction to Algorithms. The M.I.T. Press (1990). (Twentieth printing, 1998)
- Michael T. Goodrich and Roberto Tamassia.
- Data Structures and Algorithms in JAVA. John Wiley and Sons (2000). (2nd edition)
-
Supervisor:
Shengxiang Yang (sy11)
Prerequisites
The project will involve a substantial amount of object-oriented programming so students must have studied CO1004, CO1017, CO2005 and CO2006.
Aims of Project
The operating system is a layer of services of the whole computer system, which manages the hardware resources, allows the user to drive the system, and makes the boundary between hardware and software transparent. The operating system consists of four subsystems: process management, memory management, input/output management, and file management.
The aims of the memory management subsystem are to share the memory space between several concurrent processes; protect each process from each other; allow sharing of memory space, where desired; and make the addressing of memory space as transparent as possible for the programmer and end user.
The aim of this project is to develop a software package to demonstrate and animate the core working mechanisms of memory management subsystem of operating systems in either C++ or Java.
Challenges presented by the project
The potential challenges of this project are listed as follows:
- Understanding the key concepts of the memory management subsystem
- Using C++ or Java to build up a process management subsystem simulator
Learning Outcomes
The student will
- Learn about concepts and working mechanisms of memory management within operating systems.
- Learn about core algorithms used in memory management.
- Carry out specification, design and implementation of a software tool that helps teaching the memory management subsystem of operating systems.
Nature of End-Product
A practical software tool for teaching, demonstrating and animating the core concepts of memory management within operating systems.
Project Timetable
Semester1
Research on basic concepts of operating systems and core concepts of memory management, design of the architecture of the teaching tool, prototyping a simple teaching tool.
Semester2
Implement and test the whole teaching tool, finish the project report.
References
- .
- . (1901).
-
Supervisor:
Shengxiang Yang (sy11)
Prerequisites
The project will involve a substantial amount of object oriented programming so students must have studied CO1004, CO1017, CO2005 and CO2006.
Aims of Project
The operating system is a layer of services of the whole computer system, which manages the hardware resources, allows the user to drive the system, and makes the boundary between hardware and software transparent. The operating system consists of four subsystems: process management, memory management, input/output management, and file management.
The aims of the process management subsystem are to schedule resources between concurrent processes and protect each process from each other in order to maximize system throughput, be fair to all users, degrade performance gracefully when system becomes overloaded, and be consistent and predictable.
The aim of this project is to develop a software package to demonstrate and animate the core working mechanisms of process management subsystem of operating systems in either C++ or Java.
Challenges presented by the project
The potential challenges of this project are listed as follows:
- Understanding the key concepts of the process management subsystem
- Using C++ or Java to build up a process management subsystem simulator
Learning Outcomes
The student will
- Learn about concepts and working mechanisms of process management within operating systems.
- Learn about core algorithms used in process management.
- Carry out specification, design and implementation of a software tool that helps teaching the process management subsystem of operating systems.
Nature of End-Product
A practical software tool for teaching, demonstrating and animating the core concepts of process management within operating systems.
Project Timetable
Semester1
Research on basic concepts of operating systems and core concepts of process management, design of the architecture of the teaching tool, prototyping a simple teaching tool.
Semester2
Implement and test the whole teaching tool, finish the project report.
References
- Colin Ritchie.
- Operating Systems Incorporating UNIX & Windows. Continuum (2003). (4th edition)
- A. M. Lister and R. D. Eager.
- Fundamentals of Operating Systems. MacMillan (1999). (3rd edition)
- Andrew S. Tanenbaum.
- Modern Operating Systems. Prentice Hall (2001). (2nd edition)
-
Supervisor:
Alexander Kurz (ak155)
Prerequisites
Enthusiasm for an application area of your choice. Good programming skills. Knowledge of Linux.
Aims of Project
Due to the increasing amount of information available in the world wide web, there is a need for software that assists the user by autonomously performing routine (and more sophisticated) information retrieval. One of the difficulties comes from the fact that there is not a unique standard for data in the WWW. Another point is that the agents should not only search for information, but evaluate it, take autonomous actions, and notify the user only in cases of interest (which would, ideally, include learning mechanisms to continuously adapt to the users preferences extracted e.g. from the user's browsing behaviour). A simple application would be an agent that maintains a list of authors, checks their homepages for new publications, and downloads them. One refinement would be that the agent extracts an abstract or keywords and presents them to the user before downloading. More advanced agents should also be able to learn and adapt to user behaviour. For example, the agent could monitor the browsing behaviour of its user and automatically update the list of authors to be checked. Other applications could be to check stock market prices (and perhaps even do trading); to scan news (or other kind of) sources and extract useful information; a travel agent that find cheapest flights; etc.
- Research into web agents.
- Learn how to program simple agents.
- Implement a more advanced example along the lines of the one presented above.
Challenges presented by the project
Challenges vary with the particular application chosen.Learning Outcomes
The student will understanding notions such as semantic web, web-services, ontologies, intelligent web agents and have an idea of the future of the world wide web.
Nature of End-Product
A program that is able to perform automatic information retrieval in the WWW, specialised to some specific application area of your choice.
Project Timetable
Semester1
See 1 and 2 above.
Semester2
See 3 above.
References
-
Supervisor:
Artur Boronat (ab373)
Prerequisites
A good understanding of OO-programming and web applications.
Aims of Project
Design, develop and test an application for ordering books. The system will consist of two main subsystems: administration system and user system. The administration system provides: budget administration, email management to send notifications to people involved in a purchase, log of purchased books and support for statistics. The user system is a web application system that permits the creation of book orders. Every time a book is ordered, the order appears in the administration system so that the administrator confirms the order. When a book is ordered, budget information should be kept updated. Statistic information will report figures about types of books that have been purchased.
Challenges presented by the project
The challenges of this project can be found in the following areas:
- development of distributed systems
- specification, design and development of an application with several subsystems
- datamining techniques for showing statistics
Learning Outcomes
The student will learn:
- carry out a detailed requirements analysis and specification of the problem.
- produce an object-oriented design of a software system to implement
- development of distributed systems
- produce informative reports and statistics
Nature of End-Product
Software as described above.
Project Timetable
Semester1
- Specification, design and development of an initial prototype for ordering books
Semester2
- Email management
- Report generation
- Budget administration
References
-
Supervisor:
Monika Solanki (ms491)
Prerequisites
Knowledge of the Graph ADT, understanding of developing user interfaces in java
Aims of Project
The aim of this project is to implement "The Castle of Asymptopia". Inside the Castle of Asymptopia there is a maze and along each corridor there is a bag of gold coins. The amount of gold in each bag varies. A noble knight, named Sir Paul(a player) is given the opportunity to walk through the maze, picking up bags of gold. He may enter the maze only through a door marked "ENTER" and exit through another door marked "EXIT". While in the maze he may not retrace his steps. Each corridor of the maze has an arrow painted on the wall. Sir Paul may only only go down the corridor in the direction of the arrow. There is no way to traverse a "loop" in the maze. The software requires implementing a suitable algorithm to navigate through the maze. Given a map of the maze, including the amount of gold in each bag and the direction of each corridor, implement an algorithm that can help Sir Paul pick up the most gold.
Challenges presented by the project
problem analysis, graph traversal algorithms, implementation, 2D and 3D graphics.
Learning Outcomes
Understanding graph traversal algorithms, implementing the algorithms, understanding Java user interfaces, 2D and 3D graphics.
Nature of End-Product
An implementation of a graph traversal algorithm that can be extended to become a full fledged game.
Project Timetable
Semester1
Reading of background material, psuedo code for the algorithm, prototype user interface
Semester2
Completed implementation and report
References
- Data Structures and Algorithms in Java,Michael T. Goodrich and Roberto Tamassia.
-
Supervisor: Alexander Kurz
Prerequisites
Good programming skills in C/C++ or
Java.
Aims of Project
To write a chess program, using simple heuristics and
otherwise exploring `brute force' the game tree.
Challenges presented by the project
To write a substantial program. Possible
extensions may contain: A server to play chess over the
internet or strengthening the computer player by improving
implementation and heuristics.
Project Timetable
Semester1
A basic computer player.
Semester2
Adding extensions. (MinMax, alpha-beta pruning)
-
Supervisor:
Emilio Tuosto (et52)
Prerequisites
Basic knowledge of Java. Attending CO3090 may be helpful
Aims of Project
Trees are important data structures in Computer Science for instance they are very important for representing data in very efficient algorithms or to represent the syntax of terms in programming languages.
This project aims to define and implement a framework to specify and concurrently apply rules for transforming trees. Typical examples of such rules are relabelling of nodes, pruning of trees, gluing of trees, change of the root node, etc.
Challenges presented by the project
The challenges of this project is to find a user friendly environment to specify and apply transformation rules on trees in a concurrent way.
Learning Outcomes
You will acquire a solid knowledge on concurrent programming in Java.
Nature of End-Product
An concurrent environment to specify transformation rules and apply them on trees.
Project Timetable
Semester1
Review the basic knowledge on data structures; specify the requirements; design of the environment; prototype for specifying and sequentially apply the transformation rules.
Semester2
Refinement of the specification part of the prototype; implementation of the concurrent application of rules.
References
-
Supervisor:
Alexander Kurz (ak155)
Prerequisites
You are a good programmer and like sophisticated algorithms.
Aims of Project
In a famous 1972 paper (Siam Journal on Computing, 1:146-160), Robert Tarjan described several algorithms based on a simple depth first traversal of a graph. For example, he gives a linear time algorithm to discover all strongly connected components of a graph. This algorithm is crucial, for example, to some state-of-the-art model checking techniques. The aims of the project include:
- Understand and explain (some of) the algorithms of the original paper.
- Implement (some or one of) the algorithms.
- Apply (some or one of) the algorithms to the solution of some problem (as eg model checking).
Challenges presented by the project
Understanding a research paper and implementing some sophisticated algorithms.
Learning Outcomes
Understanding of an important class of advanced algorithms. Understanding of an application area. Improved programming skills.
Nature of End-Product
A program applying (some or one of) the algorithms to some application area.
Project Timetable
Semester1
Understanding and implementation of the algorithms. Desgin and specification of the application.
Semester2
Implementation of the application.
References
- R. Tarjan. Siam Journal on Computing, 1:146-160, 1972 (available from the library or from Dr.Kurz).
-
Supervisor:
Artur Boronat (ab373)
Prerequisites
A good understanding of OO-programming.
Aims of Project
Development of a tool for planning and organizing emails that can be scheduled. The tool will provide mechanisms to define email contacts and groups, to schedule emails and to organize them. A common scenario would be: the user plans to send an email to a group of friends on 20th Dec 2009 and 25 Dec 2009, when the date arrives the email is automatically send and the user is notified, the system keeps track of emails that have been sent so that they can be reused.
Challenges presented by the project
The challenges of this project can be found in the following areas:
- specification and design of a user friendly tool for organizing and sending emails
- tools for job scheduling
Learning Outcomes
The student will learn:
- to specify the requirements of an application, to design a system, to develop an application and to test it
- human-computer interaction techniques
- job scheduling
Nature of End-Product
Email organizer and scheduler as explained above.
Project Timetable
Semester1
- Research on approaches for scheduling emails
- Specification, design and development of an initial prototype for organizing contacts and scheduling emails
Semester2
- Specification, design, development and testing of a complete prototype for organizing and planning emails, including log facilities and import/export mechanisms.
References
-
Supervisor:
Fer-Jan De Vries (fdv1)
Prerequisites
Enthusiasm and interest to get involved in the topic.
Aims of Project
Genealogy has become a popular hobby when genealogical information became easily accessible online. Nowadays there is even a BBC series to encourage people to research their familiy histories. Typical questions that genealogists may ask are: "who are the ancestors of person X" or "who are the descendents of person Y" or "how are all the people with the last name Z related"? People who try to answer such questions go to (online) archives and collect family data, and share their information by making it public either on paper or online.
The aim of the project is to write tools that help budding genealogists with tasks like storing and displaying their genealogical data or testing the consistency of the data (children are not born before their parents, etc) Can you develop a simple XML language that can be used to structure genealogical data? Can you write a tool to manipulate and pretty print such XML data? Can you make a tool to display familytrees in a nice graphical way?
Challenges presented by the project
One challenge is to come to various technologies involved. Can you come up with a tool that is simple in use and that allows a genealogist to (select and) display (subsets of) his family data in various ways (either text or graphics; on paper or on the web)?
Learning Outcomes
You will become familiar with XML; you will learn how to represent graphs and trees on paper and on a webpage.
Nature of End-Product
A software package that helps the family tree builder to store, annalyse and display his/her familydata.
Project Timetable
Semester1
research and prototyping
Semester2
final product
References
-
Supervisor:
Michael Hoffmann (mh55)
Prerequisites
CO1003, CO2016
Aims of Project
Flash games became more and more popular in the past. Example of these games can be found at http://www.gamesoid.com/ The aim of this project to write your own flash game. A possible game could be a bloxorz clone. http://www.gamesoid.com/free.asp?game=bloxorz
Challenges presented by the project
The challenges of this project can be found in the following areas
- a new programming language and environment
- under the functionality and limitation of flash
- build a robust software that can be used on our public web pages.
- more specific challenges depending on the type of game that will be implemented.
Learning Outcomes
The student will:
- learn about flash.
- learn simple games design.
- carry out a detailed requirements analysis and specification of the problem.
- learn about security limitation for flash programs.
Nature of End-Product
The product of this project is Flash game.
Project Timetable
Semester1
Familiarization of Flash and a new programming environment.
Selection of game and simple game design.
Experimenting and prototyping techniques needed for the product.
Semester2
Implementing, testing and documenting the product.
References
- http://www.w3schools.com/Flash/default.asp.
-
Supervisor:
Alexander Kurz (ak155)
Prerequisites
Enthusiasm for your own project.
Aims of Project
To be defined by yourself in cooperation with the supervisor.
Challenges presented by the project
To be defined by the supervisor according to the specific topic.Learning Outcomes
Nature of End-Product
Project Timetable
Semester1
Prototype
Semester2
Final product
References
-
Supervisor:
Fer-Jan De Vries (fdv1)
Prerequisites
Enthusiasm and an original project
Aims of Project
I am open to supervise other projects besides the eight other projects that I proposed: please come to me and discuss your proposal for your own project.
Challenges presented by the project
Up to you!
Learning Outcomes
Nature of End-Product
Project Timetable
Semester1
prototype
Semester2
final product
References
-
Supervisor:
Fer-Jan De Vries (fdv1)
Prerequisites
Enthusiasm and interest to get involved in this nice game.
Aims of Project
The aim of this project will be to design and implement a system for that allows you to play the famous Game of Hex either with two human players or with one human against the system or between two systems.
Description of the Game of HexHex is a two player strategy game played on board of a NxN hexagons. Usually one plays the game at boards with N of size at least 11. The beginning player plays with black the other with white.
- Players alternately place tokens of their own colour on the board.
- A hex token may be placed at any open position (hexagon) on the board.
- Two hexagons are adjacent if they share an edge.
- Hex tokens of the same colour on adjacent hexagons are connected.
- Connectivity is transitive (the previous clause implies commutative): if a token 1 is connected to token 2 and token 2 is connected to token 3, then token 1 is connected to token 3.
- The goal of the first player is to build a group/string of connected tokens connecting column 1 with column N. The goal of the second player is to build a group/string of connected tokens connecting row 1 with row N.
Challenges presented by the project
It is a challenge is to make a reasonably strong computer player on NxN boards for arbitrary n.
Learning Outcomes
You will gain knowledge of parts of AI and game theory. You will learn to make computers playing games
Nature of End-Product
Understanding of the game. A package for playing the game with a computer: either between two humans or a human and a computer player.
Project Timetable
Semester1
Learn to play the game. Learn about game theory applicable to this particular game. Build some interface allowing two humans to play the game. Experiment with algorithms/strategies for a computer player.
Semester2
Design and implement one or more computer players.
References
- Matt Ginsberg.
- Essentials of Artificial Intelligence. Morgan Kaufmann Publishers (1993).
- V. V. Anshelevich.
- A Hierarchical Approach to Computer Hex. Artificial Intelligence, 134, pp.101-120 (2002).
- V. V. Anshelevich.
-
http://home.earthlink.net/~vanshel/.
- Berlekamp, Conway and Guy.
- Winning Ways. Volume 1 and especially 2. (1982-3).
-
Supervisor:
Fer-Jan De Vries (fdv1)
Prerequisites
Enthusiasm and interest to get involved in the topic.
Aims of Project
The aim of this project will be to design and implement a system for that allows you to play the old Game of Sheep and Wolf either with two human players or with one human against the system or between two systems.
Description of the Game of Sheep and WolfSheep and Wolf is a nice, deceivingly simple game for children. There are two players in the game: one handles the white sheep and the second handles the wolf. The game is played on a board of checkers (10 x 10, neighbouring squares have opposite colours). Initially the 5 sheep and the wolf are positioned on the black squares. The 5 sheep are all positioned on the bottom row. The wolf can start at any field that her/his player likes. All pieces can make only diagonal moves to an adjacent square. The sheep can march only forward, the wolf can walk backwards and forwards. Alternating one sheep moves and then the wolf makes a step. The sheep win when the wolf can not make a legal move anymore, for instance, when they have encircled the wolf completely. The wolf wins when he manages to break through the line of sheep and reaches the bottom row. The wolf must make the first move. he Sheep can always winIf you play the game with friends, you will note that the sheep can always win. The book "Winning ways" explains this for an 8x8 board. Does this technique extends to other board sizes as well? Can general AI techniques lead to an unbeatable Sheep player?Variant:It is an open problem whether the sheep have a winning strategy if the wolf is allowed to pass one time. Can you write a strong sheep computer player for this game?
Challenges presented by the project
It is a challenge is to make a sensible computer player for the sheep on 2nx2n boards for arbitrary n. What if the wolf is allowed to pass one move?
Learning Outcomes
You will gain knowledge of AI and game theory. You will design and implement algorithms for computer players handling then sheep or the wolf.
Nature of End-Product
Understanding of the game. A package for playing the game with a computer: either between two humans or a human and reasonably strong computer player that either plays the sheep or the wolf.
Project Timetable
Semester1
Learn to play the game. Learn about game theory applicable to this particular game. Build some interface allowing two humans to play the game. Experiment with algorithms/strategies for a computer player.
Semester2
Design and implement one or more computer players.
References
- Matt Ginsberg.
- Essentials of Artificial Intelligence. (1993).
- Berlekamp, Conway and Guy.
- Winning Ways. Volume 1 and especially 2. (1982-3).
-
Supervisor:
Stuart Kerrigan (sk223)
Prerequisites
- Good knowledge of a programming language (Java, C++, C#, .NET etc.)
- multimedia skills
- knowledge of UML
- capability of understanding new technology
- strong presentation skills.
Aims of Project
The human computer interface paradigm has evolved in recent years. No longer is interacting with a computer game necessarily a sedentary activity. Systems such as the EyeToy and Wii now use webcam and remote sensing technology to allow active participation in the game. The goal of the project(s) is to implement a computer game (or if time allows a suite of games) controlled by such means (most likely by webcam but ultimately up to the student). The exact game to implement is negotiable, but the actual game itself should be kept to a comfortable level of difficulty for the student.
Requirements for this project include
- Single player mode against an intelligent computer player
- Multiplayer competitive functionality (simultaneous or turn-based depending on nature of game).
- Investigation of different algorithms/methods for control and their effect on game playability
- Expansion of control mechanism to multiple games
- Playable when projected from computer
- Portability, program should be easily moved from one computer to another. Cross-platform compatibility is also desirable.
Challenges presented by the project
The need to learn to implement new technology, as well as potentially some image processing or remote sensing skills.
Learning Outcomes
Understanding image processing/remote sensing, Experience of game programming
Nature of End-Product
Complete working game
Project Timetable
Semester1
Design documentation
Early implementation of prototype, this could be the game controlled by conventional means (i.e. by keyboard) along with some indication of early implementation of the new HCI.
Semester2
Report
Completed Game
References
-
Supervisor:
Stuart Kerrigan (sk223)
Prerequisites
- Good knowledge of a programming language (Java, C++, C#, .NET etc.)
- multimedia skills
- knowledge of UML
- capability of understanding new technology
- strong presentation skills.
Aims of Project
The human computer interface paradigm has evolved in recent years. No longer is interacting with a computer game necessarily a sedentary activity. Systems such as the EyeToy and Wii now use webcam and remote sensing technology to allow active participation in the game. The goal of the project(s) is to implement a computer game (or if time allows a suite of games) controlled by such means (most likely by webcam but ultimately up to the student).
The intention here is to create a version of the game ofBreakoutthat is controlled via webcam or remote sensing.
Requirements for this project include
- Single player mode
- Multiplayer mode (i.e. two bats).
- Investigation of different algorithms/methods for control and their effect on game playability
- Playable when projected from computer
- Portability, program should be easily moved from one computer to another. Cross-platform compatibility is also desirable.
- Additional features to expand on the basicBreakoutgame should be added by the student.
A demonstration ofBreakoutcan be foundhere.Challenges presented by the project
The need to learn to implement new technology, as well as potentially some image processing or remote sensing skills.
Learning Outcomes
Understanding image processing/remote sensing, Experience of game programming
Nature of End-Product
Complete working game
Project Timetable
Semester1
Design documentation
Early implementation of prototype, this could be the game controlled by conventional means (i.e. by keyboard) along with some indication of early implementation of the new HCI.
Semester2
Report
Completed Game
References
- .
- . . demonstration of Breakout
-
Supervisor:
Stuart Kerrigan (sk223)
Prerequisites
- Good knowledge of a programming language (Java, C++, C#, .NET etc.)
- multimedia skills
- knowledge of UML
- capability of understanding new technology
- strong presentation skills.
Aims of Project
The human computer interface paradigm has evolved in recent years. No longer is interacting with a computer game necessarily a sedentary activity. Systems such as the EyeToy and Wii now use webcam and remote sensing technology to allow active participation in the game. The goal of the project(s) is to implement a computer game (or if time allows a suite of games) controlled by such means (most likely by webcam but ultimately up to the student).
The intention here is to create a version of the game ofPongthat is controlled via webcam or remote sensing.
Requirements for this project include
- Single player mode against an intelligent computer player
- Multiplayer competitive functionality (simultaneous or turn-based depending on nature of game).
- Investigation of different algorithms/methods for control and their effect on game playability
- Expansion of control mechanism to multiple games
- Playable when projected from computer
- Portability, program should be easily moved from one computer to another. Cross-platform compatibility is also desirable.
- Additional features to expand on the basicPonggame should be added by the student.
Challenges presented by the project
The need to learn to implement new technology, as well as potentially some image processing or remote sensing skills.
Learning Outcomes
Understanding image processing/remote sensing, Experience of game programming
Nature of End-Product
Complete working game
Project Timetable
Semester1
Design documentation
Early implementation of prototype, this could be the game controlled by conventional means (i.e. by keyboard) along with some indication of early implementation of the new HCI.
Semester2
Report
Completed Game
References
- .
- . . demonstration of Pong
-
Supervisor:
Stuart Kerrigan (sk223)
Prerequisites
- Good knowledge of a programming language (Java, C++, C#, .NET etc.)
- multimedia skills
- knowledge of UML
- capability of understanding new technology
- strong presentation skills.
Aims of Project
The human computer interface paradigm has evolved in recent years. No longer is interacting with a computer game necessarily a sedentary activity. Systems such as the EyeToy and Wii now use webcam and remote sensing technology to allow active participation in the game. The goal of the project(s) is to implement a computer game (or if time allows a suite of games) controlled by such means (most likely by webcam but ultimately up to the student).
The intention here is to create a version of the game of Tetris/Welltrix that is controlled via webcam or remote sensing.
Requirements for this project include
- Single player mode
- Multiplayer mode (i.e. two pieces controlled).
- Investigation of different algorithms/methods for control and their effect on game playability
- Playable when projected from computer
- Portability, program should be easily moved from one computer to another. Cross-platform compatibility is also desirable.
- Additional features to expand on the basic Tetris (or Welltrix, the 3D variant) game should be added by the student.
Challenges presented by the project
The need to learn to implement new technology, as well as potentially some image processing or remote sensing skills.
Learning Outcomes
Understanding image processing/remote sensing, Experience of game programming
Nature of End-Product
Complete working game
Project Timetable
Semester1
Design documentation
Early implementation of prototype, this could be the game controlled by conventional means (i.e. by keyboard) along with some indication of early implementation of the new HCI.
Semester2
Report
Completed Game
References
-
Supervisor:
Artur Boronat (ab373)
Prerequisites
A good understanding of OO-programming. Interest in web services.
Aims of Project
Bibliographical information is available through the web in different formats, bibtex is one of them. The aim of this project is to develop an application to query information about books from different sources (Amazon, Google scholar,...) and to keep information about these books in a local database. The application has to detect when a book is in the local database. An interface to provide advanced search of books is also required.
Challenges presented by the project
The challenges of this project can be found in the following areas:
- Development of a system based on third-party web services
- Integration of heterogeneous information
Learning Outcomes
The student will learn:
- specify the requirements of an application, design a system, develop an application and test it
- how to develop distributed systems
- web services
- how heterogeneous information can be queried, manipulated and stored.
Nature of End-Product
Software application as described above.
Project Timetable
Semester1
- Development of a database for storing bibliographical references
- Specification, design and development of an initial prototype for searching books through amazon
Semester2
- Advanced search
- Specification, design and development of a prototype for searching books through google scholar and querying the local database
References
-
Supervisor:
Artur Boronat (ab373)
Prerequisites
Good background in Java and UML (class diagrams and object diagrams).
Aims of Project
Model-Driven Development (MDD) is a new paradigm to develop software in a semi-automatic way. In a MDD approach, Code is represented by means of models (usually UML diagrams) from which many different tasks can be automated: reverse engineering, refactoring, automatic code generation or generation of other software artifacts (other models). This paradigm has received the attention of the big software companies, such as IBM (Eclipse Modeling Project) or Microsoft (DSL Tools), in the last years.
The goal of this project consists in generating a model-based programming environment for a programming language. This involves:
- Automatic generation of parsers and programming environments for theEclipse platformby usingopenArchitectureWare
- Automatic generation of code by usingJET, or similar technology.
- Other features that student may add.
The programming language of interest is chosen by the student.
Challenges presented by the project
This project offers many challenges that will lead the student to the last trends in industrial software development. Some of them are listed as follows:
- Understanding MDD and how it increases the productivity in the software development.
- Use of the experimental openArchitectureWare framework.
- Understanding of the Eclipse platform.
Learning Outcomes
- Learn about MDD, metamodeling, automated generation of parsers and compilers.
- Use of UML class diagrams for metamodeling.
- Gain experience in languages and tools currently used in MDD.
- Get an insight into scientific and industry-oriented research.
- Get experience with the development of plugins for the Eclipse platform.
Nature of End-Product
Eclipse-based programming environment for a given language.
Project Timetable
Semester1
Study and experimentation with: Eclipse Modeling Framework, openArchitectureWare (language xText) and JET. First prototype.
Semester2
Complete prototype, examples and report.
References
-
Supervisor:
Michael Hoffmann (mh55)
Prerequisites
A good understanding of databases and OO-programming (CO1003, CO1004, CO1015, CO2005).
Aims of Project
Go is an board game and has in Asia a similar status as chess in Europe. The aim of the project is to write a notation program for go. Each move should be recorded, together with comments and possible alternative move.
Challenges presented by the project
The challenges of this project can be found in the following areas
- Efficient structure of data
- Design of efficient algorithm
- Visualization of alternative moves
- Finding similar situation in different recorded matched
Learning Outcomes
The student will:
- carry out a detailed requirements analysis and specification of the problem.
- produce an objected-oriented design of a software system to implement
- learn about human computer interaction
Nature of End-Product
The end product will be a go notation program.
Project Timetable
Semester1
A detailed specification of the program.
Prototyping of the GUI and the board display.
Semester2
Implement the specification and test the program
References
-
Supervisor:
Michael Hoffmann (mh55)
Prerequisites
Good understanding of algorithm. Good programming skills in either Java or C++.
Aims of Project
A graph is a collection of nodes and collection of edges connecting two nodes. You can think of a graph like a computer network, where a node is a computer or hub and each edge corresponds to a cable between two components.
A wide and interesting area is the colouring of graphs. Given a graph and some colours. For example the task is to Colour each node such that no two nodes with the same colour are connected by an edge.
Recently a tool for creating counter example for certain types of colouring has be developed in Leicester. The current tool produces very large counter example where actually smaller ones are available.
The aim of this project to write a tool that firstly verifies that the previously found examples can not be colouring under a certain condition. Finding smaller ones and representing the examples in a graphic form.
Challenges presented by the project
The challenges of this project can be found in the following areas
- Understanding the problem of graph colouring under certain conditions.
- Understanding recent research paper in that area.
- Representing graphs and their colouring inside a program
- Inventing new algorithms to find smaller counter examples.
- Implementation and visualisation of efficient algorithms
Learning Outcomes
The student will:
- Be able to discuss the problem of graph colouring.
- Be able to compare different approaches in that area.
- Design a tool for testing colouring of graphs.
Nature of End-Product
A software tool to test and create counter examples for graph colouring under certain conditions.
Project Timetable
Semester1
Reading of background material.
Selection of the data structure for the graph and colouring.
Review the existing tool.
Prototype for testing if a given colouring of a graph is valid.
Semester2
Present graphs and their colouring graphically
Design and implementation of new algorithm.
References
-
Supervisor:
Shengxiang Yang (sy11)
Prerequisites
The project will involve a substantial amount of programming involving Algorithms and Data Structures. This should be in a object oriented style so students must have studied CO1004, CO2004 and CO2005.
Aims of Project
The Shortest Path Problem (SPP) can be stated as follows: given a weighted network G in which each edge has a weight representing the length of the edge, the objective of Shortest Path Problem is to find a shortest path from some node s, called the source to another node, called the sink, in G. The SPP problem is the basic ingredient problem in network optimization problems. It also has numerous applications in other areas.
Many tranditional algorithms have been proposed for the SPP problem. However, in nature the ant colony can also solve the SPP problem when they are searching for food. From this researchers developed Ant Colony Optimisation (ACO) algorithms. The aim of this project is to design, implement, and demonstrate ACO algorithms and some tranditional optimization algorithms for SPPs with comparison of their performance in either C++ or Java.
Challenges presented by the project
The potential challenges of this project are listed as follows:
- Understanding some tranditional optimization algorithms for the SPPs
- Implementing the Ant Colony Optimisation (ACO) algorithm to solve the SPPs in C++ or Java
- Animating the algorithm progress of solving SPPs
Learning Outcomes
- Learn about the Shortest Path Problem.
- Learn about algorithm engineering.
- Learn about ant colony optimisation algorithms.
- Implement several optimization algorithms for solving the Shortest Path Problem.
- Build a simple software package.
Nature of End-Product
A practical software package of different algorithms, including the ant colony optimisation for solving the Shortest Path Problem.
Project Timetable
Semester1
Research on the Shortest Path Problem, ant colony optimisation algorithm, design of algorithms and package, prototyping a simple system.
Semester2
Implement and test the system, finish the project report with experimental results.
References
- Thomas H. Cormen, Charles E. Leiserson and Ronald L. Riverst.
- Introduction to Algorithms. The M.I.T. Press (1990). (Twentieth printing, 1998)
- Michael T. Goodrich and Roberto Tamassia.
- Data Structures and Algorithms in JAVA. John Wiley and Sons (2000). (2nd edition)
- K. Mehlhorn and S. Naher.
- LEDA: A Platform for Combinatorial and Geometric Computing. Cambridge (1999).
- Eric Bonabeau, Marco Dorigo and Guy Theraulaz.
- Swarm Intelligence From Natural to Artificial Systems. Oxford University Press (1999).
-
Supervisor:
Roy Crole (rlc3)
Prerequisites
This project requires familiarity with either a functional or object oriented programming language. If you enjoyed CO2008 Functional Programming you are likely to enjoy this project which is ideally suited to coding in a functional style; however coding in OO style is also quite acceptable. A short version of this project is also ideal for a 20 credit Maths and Computer Science project.
Aims of Project
Programming languages can be specified at different levels of abstraction. At the lowest level we have processor microprogramming, and at the highest we have programming languages such as Haskell and Java. A method known as structured operational semantics (SOS) allows computer scientists to describe the syntax (written language) and semantics (the meaning or execution behaviour) of high level languages, without concern for the complication of low level machine detail. In fact, a SOS amounts to a description of an interpreter.
The aim of this project is to study a simple high level language (let's call it L) by describing L using a SOS, and then implementing the SOS-interpreter for L within a real language such as C++, JAVA or Haskell.
Challenges presented by the project
This is a reasonably challenging project, but the reward will be learning a great deal about the ways in which high level languages can be defined, and the ways in which they execute. Also, this project ties up very well with the module CO3008, Semantics of Programming Languages. The key challenges are to understand how a collection of syntax "rules" can be used to give a high level description of run-time behaviour; and how to turn such rules into interpreter code.
Learning Outcomes
- An account of the SOS of a simple language L.
- Review of an appropriate programming language in which the SOS will be implemented.
- The construction of a parser for L.
- The implementation of the SOS-interpreter for L (this will be a substantial part of the project).
Nature of End-Product
Implementation of SOS-interpreter, including a user friendly interface. The inputs will be simple L programs, and the outputs will be illustrations of the execution of the L program.
Project Timetable
Semester1
Review/learn an appropriate programming language, study the SOS of a small high level language L, specify and design the SOS-interpreter.
Semester2
Implement the SOS-interpreter, build a GUI, and write up project report.
References
- .
- . . References can be obtained from Dr.~Roy~Crole.
-
Supervisor:
Alexander Kurz (ak155)
Prerequisites
Enthusiasm for an application area of your choice. XML. Good programming skills.
Aims of Project
Relational databases are good for data that has a predetermined format. Semistructured data is data that has some structure, but this structure may change during the life of the system in unpredictable ways. An example is, of course, the world wide web. But this project is about the simpler case where a specific domain has been determined. For example, a student, or a researcher, or a teacher, or a journalist, or a secret service, will want to organise their material in a flexible way that allows for the type of data as well as their relationships to change during time.
- Describe your area of application and the methods you think appropriate to administrate and organise the data. Research into cognitive aspects of conceptualising a domain.
- Develop a model of your application area based on XML.
- Implement mechanisms that allow you to update and query the data.
- Provide a graphical user interface.
Challenges presented by the project
To understand and partially solve the problems related to semi-structured data.Learning Outcomes
- XML.
- Understanding and managing semi-structured data.
Nature of End-Product
A small data base system for semi-structured data, tailored to a specific application area.
Project Timetable
Semester1
1 and 2 above and a prototype for (parts of) 3.
Semester2
3 and 4.
References
-
Supervisor:
Artur Boronat (ab373)
Prerequisites
A good understanding of OO-programming.
Aims of Project
Amind mapis a diagram used to represent words, ideas, tasks, or other items linked to and arranged around a central key word or idea. Mind maps are used to generate, visualize, structure, and classify ideas, and as an aid in study, organization, problem solving, decision making, and writing. The aim of this project is to develop a graphical tool for representing and organizing ideas in a discussion meeting.
Challenges presented by the project
The challenges of this project can be found in the following areas:
- design of a user friendly tool for sharing knowledge
- use of graphical libraries in an efficient way
- definition of a modeling language for defining mind maps
Learning Outcomes
The student will learn:
- to specify the requirements of an application, to design a system, to develop an application and to test it
- to use graphical libraries for defining graphs
- human-computer interaction techniques
- to define and develop an editor for a graphical modeling language
- modeling techniques
Nature of End-Product
Graphical editor for defining mind maps as described above.
Project Timetable
Semester1
- Research on approaches for defining mind maps
- Research on graphical libraries for representing graphs
- Specification, design and development of an initial prototype for defining mind maps
Semester2
- Development of a modeling language for defining mind maps
- Specification, design and development of a complete prototype for defining mind maps, importing and exporting them
References
-
Supervisor:
Alexander Kurz (ak155)
Prerequisites
You like mathematics and want to learn about logic and an application of logic in computer science.
Aims of Project
Model checking is a fascinating technology with a wide range of industrial applications in the verification of communication protocols. It allows to specify properties of protocols in specially designed logics, usually variants of modal and temporal logics, which are then verified automatically.
- Learning about LTL, linear temporal logic.
- Implementing a LTL-model checker.
Challenges presented by the project
Learn about LTL and model checking. Understanding and implementatingadvanced state of the art algorithims.Learning Outcomes
Familiarity with aspects of formal methods, automatic verification of programs, temporal logic, model checking.
Nature of End-Product
A basic model LTL-model checker.
Project Timetable
Semester1
See 1 above; and a prototype for 2.
Semester2
See 2 above.
References
-
Supervisor:
Artur Boronat (ab373)
Prerequisites
A good understanding of OO-programming.
Aims of Project
Software artifacts in industrial applications can consist of thousands of code files. To enhance software maintenance of such applications techniques to abstract essential information from code are crucial. Model-driven development techniques enable the representation of code as models (collections of objects) from which code is generated. The aim of the project is to define a graphical visualizer for representing models as object diagrams (objects and links) that provides techniques for hiding/adding information at different levels of granularity: to show clusters of objects with similar properties (instances of the same class), clusters of highly cohesive objects (with many links among them), etc.
Challenges presented by the project
The challenges of this project can be found in the following areas:
- graphical representation techniques
- model-driven development techniques: including parsers and code generation techniques
- metamodelling techniques for defining modelling languages (metamodels) and models
- develop an application that enables the representation of models as object diagrams (graphs)
Learning Outcomes
The student will:
- carry out a detailed requirements analysis and specification of the problem.
- produce an object-oriented design of a software system to implement
- learn about model-driven development and metamodeling techniques
- learn about visual representation techniques of graphs
- learn about Eclipse Modeling Framework and its application for model-driven software development
Nature of End-Product
A graphical editor for representing models with zoom facilities
Project Timetable
Semester1
- Learn basic notions of model-driven development: model, metamodel, Eclipse Modeling Framework
- Explore techniques for graphical representation of graphs
- Specification, design, implementation and testing of a first prototype
Semester2
- Explore clustering techniques based on graphs
- Define algorithm for zooming: decide which information to show/hide
- Complete specification, design, implementation and testing of the prototype
References
- EMF.
- Eclipse Modeling Framework (2009). http://www.eclipse.org/emf
-
Supervisor:
Michael Hoffmann (mh55)
Prerequisites
Good programming skills in Java or C++. CO1003, CO1004 or CO2005, CO2006, CO2016
Aims of Project
The aim of project is to create a virtual 3D environment. In this multiple user, divided in two teams, will be able play a game of air hockey.
Challenges presented by the project
The challenges of this project can be found in the following areas
- orientation in a 3D-environment
- animation with respect of physical laws (momentum, spin)
- effective collision detection
- handling of non player controlled (NPC) components
- data management on distributed systems,
- networking (minimizing lag and the effect of lag)
Learning Outcomes
The student will:
- learn about techniques for representing and working with 3D landscapes on a computer.
- learn about simulating physical behaviors.
- carry out a detailed requirements analysis and specification of the problem.
- learn about distributed programming including client-server architectures.
- implement the client, server, user interfaces and communications protocols
Nature of End-Product
The product of this project is multiplayer air hockey game.
Project Timetable
Semester1
A detailed specification of both the client and the server.
Prototyping the client/server aspects of the projects
Prototyping the graphical aspects of the projects
Research on the physical behavior and on algorithms to simulate them
Semester2
Implementing, testing and documenting the product.
References
- Henry Sowizral, Kevin Rushforth and Michael Deering.
- The Java 3D API Specification. Addison-Wesley (1998).
-
Supervisor:
Michael Hoffmann (mh55)
Prerequisites
CO1003, CO1004 or CO2005, CO2006, CO2016
Aims of Project
The aim of project is to create a muliplayer clone of the classic game xkobo (http://olofson.net/kobodl/).
Challenges presented by the project
The challenges of this project can be found in the following areas
- Sprite and image handling in 2D
- learn about distributed programming including client-server architectures.
- implement the client, server, user interfaces and communications protocols
- Handling of non player controlled (NPC) components (e.g.:other space ships)
Learning Outcomes
The student will:
- Learn about techniques for representing and working with 2D environments.
- implement the client, server, user interfaces and communications protocols
- carry out a detailed requirements analysis and specification of the problem.
- learn about distributed programming including client-server architectures.
Nature of End-Product
The product of this project is a multiplayer xkobo clone.
Project Timetable
Semester1
A detailed specification of both the client and the server.
Research and prototyping of 2D graphic libraries including sprite handling.
Prototyping the graphical aspects of the projects
Prototyping the graphical and client/server aspects of the projects
Semester2
Implementing, testing and documenting the product.
References
-
Supervisor:
Shengxiang Yang (sy11)
Prerequisites
The project will involve a substantial amount of programming involving Algorithms and Data Structures. This could be in an object oriented style so students must have studied CO1004, CO2004, and CO2005.
Aims of Project
The Job-shop Scheduling Problem (JSP) can be stated as follows: given N jobs to be processed on M machines in a prescribed order under certain restrictive assumptions. The objective of job-shop scheduling is to optimally arrange the processing order and the start times of operations to optimize certain criteria, such as the due date reliability, the mean lead time, and the makespan (the time required to process all of the given set of jobs). Minimizing the makespan will be considered as the main optimization criterion in this project. The JSP problem is one of the most complicated and typical constraint satisfaction problems. Usually, it is NP-hard combinatorial optimization problem and arises in numerous applications, especially in the manufacturing systems.
The aim of this project is to design and implement a simple software package using Genetic Algorithms (GAs) or other algorithms for JSP in either C++ or Java.
Challenges presented by the project
The potential challenges of this project are listed as follows:
- Understanding the key aspects of the production scheduling system
- Implementing genetic algorithms to solve the job-shop production scheduling system in C++ or Java
- Animating the production scheduling system
Learning Outcomes
- Learn about the Job-shop Scheduling Problem.
- Learn about algorithm engineering.
- Learn about general Genetic Algorithm.
- Implement some optimization algorithms (e.g. GAs) for the Job-shop Scheduling Problem.
- Build a simple software package.
Nature of End-Product
A practical software package for solving the Job-shop Scheduling Problem.
Project Timetable
Semester1
Research on the Job-shop Scheduling Problem, Genetic Algorithms and related algorithms, design of algorithms and package.
Semester2
Implement and test the algorithms, finish the project report with experimental results.
References
- Thomas H. Cormen, Charles E. Leiserson and Ronald L. Riverst.
- Introduction to Algorithms. The M.I.T. Press (1990). (Twentieth printing, 1998)
- Michael T. Goodrich and Roberto Tamassia.
- Data Structures and Algorithms in JAVA. John Wiley and Sons (2000). (2nd edition)
- D. E. Goldberg.
- Genetic Algorithms in Searching, Optimization and Machine Learning. Addison-Wesley, Reading, (1989).
- Zbigniew Michalewicz.
- Genetic Algorithms + Data Structures = Evolution Programs. Springer-Verlag (1999). (3rd edition)
-
Supervisor:
Stuart Kerrigan (sk223)
Prerequisites
Programming skills, interest in multimedia, also (potentially) programming for the internet.
Aims of Project
The aim of this project is to create a tool that can be used to create promotional application that could be given away on CD-ROM. This application would use video, text, audio and more importantly interactive activities simple (games such as jigsaw puzzles).
The tool should be created to allow editting and updating of old content and the creation of new content. So for instance you might write an interactive package showing the user round a gym, but another user could write a promotional package for a supermarket using their own graphics, audio, text etc.
You should also have example content to show off your tool!
Challenges presented by the project
This project is very open-ended - the application is specific while the tool is very general. Good organisation and planning will be required by any student undertaking it.
Learning Outcomes
A package for playing the game with a computer: either between two humans or a human and a computer player.
Nature of End-Product
Promotional package on CD-ROM
Tool for creation/editting of promotional packages
Project Timetable
Semester1
Prototype.
Design
Semester2
Finished product
References
- .
- . (1901).
-
Supervisor:
Fer-Jan De Vries (fdv1)
Prerequisites
Enthusiasm and creativity.
Aims of Project
In many situations it is important to know for sure that your programs complete their tasks and don't run forever. The aim of this exciting project will be to design and implement a system that given program tries to decide whether or not it will terminate on any given input. To make life simple we will not study real programs in a full-grown programming language, but we will study rewriting systems. These are very simple, but very expressive formalisms, and therefore very useful for rapid prototyping.
Challenges presented by the project
It is a challenge to understand enough of rewriting to implement the termination algorithms.Learning Outcomes
- You will become familiar with some ideas and concepts from the Theory of Rewriting,
- you will study some termination algorithms,
- And you will get the experience of converting theoretical algorithms into concrete programs.
Nature of End-Product
An implementation of a system which is able to test whether a rewriting system terminates. And who knows what else you come up with!
Project Timetable
Semester1
Study of rewriting and termination algorithms. Make some prototype software that can handle rewrite systems and make a reasonably detailed plan for the remaining software you will write in the second semester.
Semester2
Implementation of one or two termination deciding algorithms. And if time permits some testing on an interesting example. For instance: is your software able to show that the sorting algorithms that you learned indeed terminate with a sorted list?
References
-
Supervisor:
Shengxiang Yang (sy11)
Prerequisites
Students should have studied CO1004, CO1017, CO2004, CO2005 and CO2006.
Aims of Project
One key function in the communication networks is routing packets/data from the source machine to the destination machine over the communication networks. The routers in the subnets receive packets, store them, and forward them to suitable neighbour routers until the packets arrive at the destination machine. The routing algorithms used by the routers are responsible for deciding which output line an incoming packet should be transmitted to.
The aim of this project is to develop a software package to demonstrate and animate the core working mechanisms and algorithms of routers in communication networks in either C++ or Java.
Challenges presented by the project
The potential challenges of this project are listed as follows:
- Understanding several routing algorithms
- Using C++ or Java to animate several routing algorithms
Learning Outcomes
The student will
- Learn about concepts and working mechanisms of routers in communication networks.
- Learn about core algorithms used by routers.
- Carry out specification, design and implementation of a software tool that helps teaching the routing process in communication networks.
Nature of End-Product
A practical software package of demonstrating and animating the core concepts and algorithms of packet routing in communication networks.
Project Timetable
Semester1
Research on basic concepts of the communication networks and core concepts and algorithms of packet routing in the communication networks, design of the architecture of the simulation system, prototyping a simple simulation system.
Semester2
Implement and test the whole simulation system, finish the project report.
References
- Andrew S. Tanenbaum.
- Computer Networks. Prentice Hall (2003). (4th edition)
- William Stallings.
- Data and Computer Communications. Prentice Hall (2000). (6th edition)
-
Supervisor:
Fer-Jan De Vries (fdv1)
Prerequisites
Enthusiasm and interest to get involved.
Aims of Project
Recently Sudoku has recently become very popular outside Japan. Sudoku puzzles appear daily in most newspapers. Perhaps Sudoku was invented in Japan to have a counterpart for the crosswords which don't work well in the Japanese script. Slitherlink is another interesting Japanese puzzle.
Can you make software tools that help solving and or creating such puzzles?
Challenges presented by the project
Plenty: Can you write a program that solves such puzzles? Can you write a program that gives hints to a human problem solver? Can you write a tool to design such puzzles?
Learning Outcomes
A great experience in problem solving and programming. You will learn/apply some AI.
Nature of End-Product
A package to help a human to solve and or create such puzzles online.
Project Timetable
Semester1
prototype
Semester2
final product
References
- Matt Ginsberg.
- Essentials of Artificial Intelligence. Morgan Kaufmann Publishers (1993).
- .
- I learned about these puzzles via a Japanese puzzlebook, published in 1993 by the Japanese publisher Nikoli
-
Supervisor:
Artur Boronat (ab373)
Prerequisites
A good understanding of OO-programming.
Aims of Project
Software applications are evolving constantly and mechanisms to perform changes and to track them help in maintaining applications. For instance, when a relational schema is defined from a class diagram the correspondences between the elements in both the class diagram and the relational schema could be tracked by means of mappings so that if a class is modified we can easily find out which table needs to be updated. The aim of this project is to provide a graphical mapping tool to enhance software evolution.
Challenges presented by the project
The challenges of this project can be found in the following areas:
- software evolution and change propagation
- model-driven development techniques for defining software artifacts
- graphical visualization of mappings
Learning Outcomes
The student will learn:
- to specify the requirements of an application, to design a system, to develop an application and to test it
- techniques for software evolution and change propagation
- use graphical libraries for implementing user-friendly tools
- model-driven development techniques for representing software artifacts
Nature of End-Product
Graphical tool for mapping software artifacts.
Project Timetable
Semester1
- Study model-driven development techniques for representing software artifacts: metamodeling techniques, XML, Eclipse Modeling Framework/Microsoft DSL tools/Microsoft Oslo
- Specification, design and development of an initial prototype for mapping software artifacts
Semester2
- Development of a language for defining mappings to keep track of changes.
- Specification, design, development and testing of a complete graphical environment for mapping software artifacts and to traverse mappings.
References
-
Supervisor:
Michael Hoffmann (mh55)
Prerequisites
Good programming and problem solving skills
Aims of Project
Sokoban is an old puzzle games from the early 1980's.
Over the years Sokoban was subject to some scientific research. Benchmarks and competition for Sokoban solver were established.
Some aspects of more modern puzzle games can be traced back to Sokoban.
The aim of the project is create a Sokoban clone and write your own Sokoban solver.
wikipedia on Sokoban
collection of levels (Sasquatch) Challenges presented by the project
The challenges in this project lie in:
- building a robust game
- storing a game history to allow 'undos'
- dealing with very large search space
- problem analysis and problem solving
Learning Outcomes
The student will learn about the complexity of algorithm, techniques to reduce a search space, solve problems in a systematic way
Nature of End-Product
A Sokoban clone with a build in solver
Project Timetable
Semester1
- Analyzing required skills for the project
- Gaining skills needed and write the Sokoban clone
- reading about how to deal with large search spaces
Semester2
- creating simple solver
- increase functionality to load in benchmark levels
- improving the solver
- analyzing and evaluating your findings
References
- .
- . (1901).
-
Supervisor:
Michael Hoffmann (mh55)
Prerequisites
CO1003, CO1004 or CO2005, CO2006, CO2016.
Aims of Project
The aim of project is to create a teaching tool for CO2016. This tool should have the normal functions of sound mixer-editor and visualize the sound data at each state. Also it should have a 'plugin' option so that classes written by students will be used to manipulate the sound.
Challenges presented by the project
The challenges of this project can be found in the following areas
- Sound Handling
- HCI: handling of different tracks and visualization of the sound
- Imbedding of 3rd party code
Learning Outcomes
The student will:
- Learn about complex techniques for handling sound.
- Learn about securely run 3rd party classes in Java.
- carry out a detailed requirements analysis and specification of the problem.
Nature of End-Product
The product of this project is a audio mixer-editor teaching tool for CO2016 as described above.
Project Timetable
Semester1
A detailed specification of the 'plugin' architecture.
Research and prototyping of the audio libraries in Java.
Prototyping the audio data handling and visualization.
Semester2
Implementing, testing and documenting the product.
References
-
Supervisor:
Stuart Kerrigan (sk223)
Prerequisites
Graphic and image processing skills, some mathematics, good programming skills
Aims of Project
Point Distribution Model is a model for representing the mean geometry of a shape and some statistical modes of geometric variation inferred from a training set of shapes. It relies on Landmark points.
For instance here are some landmark points you might find on a face:-
Your task for this project would be to implement an Point Distribution Model and apply it to a real life dataset of images.
Challenges presented by the project
- Familiarising oneself with literature - good practice for a student considering a career in research
- Familiarisation with dataset
Learning Outcomes
- Computer Vision
- 2D image manipulation
- Research skills
Nature of End-Product
A software tool to allow demonstration of the principles of a Point Distribution Model.
Project Timetable
Semester1
- Reading of background material.
- Prototype
Semester2
Completed project + report.
References
-
Supervisor:
Michael Hoffmann (mh55)
Prerequisites
CO1003, CO1004 , CO2006, CO2016
Aims of Project
The aim of project is to create an editor for SVG in Java. The user should be able to draw shapes and other SVG components. Also the user should be able to specify different animations for the components. The editor will output SVG code in XML format.
Challenges presented by the project
The challenges of this project can be found in the following areas
- Good HCI
- The data representation of the drawing.
- read and write XML files
- Effective use of advanced SVG components
Learning Outcomes
The student will:
- learn about advanced SVG components and related standards.
- carry out a detailed requirements analysis and specification of the problem.
- implement a good HCI for the required drawing tool.
- carry out a detailed requirements analysis and specification of the problem.
Nature of End-Product
The product of this project is a SVG editor.
Project Timetable
Semester1
Choose the internal data representation of the drawing.
Prototyping the drawing tool.
Import and export simple SVG code in XML format.
Research on the advanced SVG components.
Semester2
Implementing, testing and documenting the product.
References
-
Supervisor:
Stuart Kerrigan (sk223)
Prerequisites
Multimedia skills, familiarity with 3D geometry, good programming skills
Aims of Project
Measurements oftotal hip replacements(THRs) are performed on radiographs (colloquially known as x-rays). This is a 2D projection of a 3D scene, thus error is introduced.
The aim of this project is to create a package that allows the creation of synthetic THR images from a 3D scene created from user entered parameters (such as how far apart the components are) and can estimate the error introduced to measurements performed on these synthetic images due to the projection from 2D to 3D.
Here is a sample (real) radiograph:-
Challenges presented by the project
- Familiarising oneself with THR literature - good practice for a student considering a career in research or working in a multi-disciplinary team
- Understanding the concept of measurements and error estimation
Learning Outcomes
- 3D modelling
- 2D projection
- Research skills
Nature of End-Product
A software tool to allow manipulation of 3D scene, produce synthetic images, perform measurements on both synthetic image and 3D scene and compare the measurements.
Preliminary investigation into magnitude of error introduced by 3D to 2D projection
Project Timetable
Semester1
- Reading of background material.
- Selection of particular measurements to investigate.
- Prototype of 3D scene.
Semester2
Completed project + report.
References
- Stuart Kerrigan.
- Eccentricity Error Correction for Automated Estimation of Polyethylene Wear after Total Hip Arthroplasty. (2005). Available online atmy website.
- Stuart Kerrigan.
- Automated Assessment of Polyethylene Wear in Cemented Acetabular Components using Anteroposterior Radiographs of Total Hip Replacements, Computerized Medical Imaging and Graphics. (2008).
-
Supervisor:
Fer-Jan De Vries (fdv1)
Prerequisites
Enthusiasm and interest to get involved in the topic.
Aims of Project
The aim of this project will be to design and implement a XML driven database that would allow a group of birdwatchers (say the Leicestershire and Rutland Ornithological Society) to input their bird observations in the club computer via an intelligent home page over the internet using modern Google Maps technologies.
The page should allow for a simple and quick way of inputting of data. The page should provide some easy tools for performing some elementary statistics on the data. Its should provide an easy interface to query the database.
Location data provides various particularly interesting challenges: either one inputs raw coordinates of a location (the birder may use a map or GPS), or one input locations with help of a clickable map.
Nowadays Google provides maps in great detail of large parts of the earth and all kind of tools to manipulate them. Find a way to use these maps. (For an example of combining user data with Google maps see www.houseprices.co.uk) The outcome of certain queries can now well be a map: eg, imagine a map with all breeding locations of the Sparrowhawk in Leicestershire.
Challenges presented by the project
There are all kind of challenges: one has to come to grips with and combine all the various technologies involved. The design and implementation of a tool that is simple in use and allows the birdwatchers to query their data and display the resulting data in various ways. Another interesting challenge is to link the Google maps in a clever and useful way to the database.
Learning Outcomes
Experience in representing complex data in XML, and writing tools to input and analyse the data via a website. Experience with Google Maps.
Nature of End-Product
An analysis what kind of data birdwatchers like to collect and store in a database, an analysis how inputting such data can be facilitated and checked for correctness/reasonability. An analysis of the kind of statistics that birdwatchers may perform on their data. A design and an implementation of an actual piece of birding software that is ready for use and that helpful for bookkeeping of bird observations.
Project Timetable
Semester1
Definition of a suitable XML format for birding data. Experimentation with prototypes. Design of final product.
Semester2
Implementation of final product.
References
- See http://www.w3.org/XML/1999/XML-in-10-points for a brief introduction to XML by W3.
- See http://www.lros.org.uk for the homepage of the Leicestershire and Rutland Ornithological Society
- See http://www.google.com/apis/maps/ for how to put Google Maps on your website.
-
Supervisor:
Alexander Kurz (ak155)
Prerequisites
Good programming skills, knowledge of Java or C/C++.Aims of Project
Yahtzee is a highly addictive dice game. It can be played by any number of people. The goal is to achieve the highest score by rolling certain combinations of five dice.
The aim of the project is to create a strong computer Yahtzee player. The end-product should implement asubsetof the following:
- A nice looking GUI and a game-playing engine which controls the players moves and evaluate their scores.
- A server which allows many clients to play the game over a LAN or the Internet.
- A computer player based on some ad-hoc strategy(ies) developed by the student.
- A computer player based on the "near optimal" strategy proposed by O. Vancura (see the references below).
- A program that "solves" the game by using retrograde analysis.
A typical project has to include implementations of the first item together with one at least one of the others.
Challenges presented by the project
To develop a good computer player.Learning Outcomes
- Design and implementation of a computer dice game.
- Client-server technologies if you choose 2.
- Understanding and/or developing good heuristic strategies (3 and/or 4).
- Retrograde analysis if you choose 5.
Nature of End-Product
A computer program as described earlier.
Project Timetable
Semester1
Research on the rules of Yahtzee and at least one of the following: client-server technologies, strategies in games, retrograde analysis. Design and implementation of the core of the system as described in 1.
Semester2
Research, development and implementation of at least one of the more advanced features 2-5.
References
- Olaf Vancura.
- Advantage Yahtzee: The Official Handbook. Huntington Press (2001).
-
Supervisor:
Monika Solanki (ms491)
Prerequisites
Knowledge of programming in java, developing user interfaces, databases.
Aims of Project
The aim of this project is to build a Theater ticket booking system for mobile devices using Java ME. Java Platform, Micro Edition (Java ME) provides a robust, flexible environment for applications running on mobile and other embedded devices, mobile phones, personal digital assistants (PDAs),
The application should allow a user to book tickets using their mobile devices. Information regarding tickets, venues, shows and timings are stored in an open source SQL database. The application should allow a user to seacrh for shows, choose a venue, select timings and then book tickets.
Challenges presented by the project
programming mobile devices, Java ME
Learning Outcomes
A good understanding of how to build applications for mobile devices, the Java ME framework.
Nature of End-Product
An application for booking tickets via mobile devices
Project Timetable
Semester1
Learning the Java ME framework, learning various other markup languages for mobile devices, understanding the open source database chosen for the project.
Semester2
Programming the application, producing a report
References
- Java ME framework, WML, WAP, MySQL.
- . (1901).
-
Supervisor:
Michael Hoffmann (mh55)
Prerequisites
This project requires familiarity with the module CO2011 and also knowledge of programming (as may be found in CO1003 and CO1004, or in equivalent modules).
Aims of Project
Finite state automata were introduced in the module CO2011. A two tape finite state automaton can read two taped either synchronously or asynchronously. In the project we will focus on the former one.
There are several interesting operation on these automata. For example converting a two tape automaton to a normal finite state automaton by restricting the 2nd tape. These operation are important in designing algorithm in recent research projects.
The idea of this project would be to build a tool that would simulate operation on two tape automata. Analysing which data structure for two tape automata would give which complexity bounds for the above operations.
Challenges presented by the project
The challenges of this project can be found in the following areas
- Handling of data in different formats and their conversion
- Understanding and implementing of advanced operation involving two tape automata
- Implementation and visualisation of efficient algorithms
Learning Outcomes
The student will:
- Learn some advanced material (such as the method of combining 2 two tape automata to one.).
- Construct a tool for representing two tape automata and operations on them.
- Design a tool for simulating the action of a two tape automaton.
- Combine these tools into a general purpose tool for two tape automata.
Nature of End-Product
A tool allowing to create two tape automata and perform operations on them.
Project Timetable
Semester1
Review finite state automata. Research some further material on two tape automata and related subjects. Specify the tools to be implemented. Decide on the data structure. Prototyping simple displays of automata.
Semester2
Design, implement and test the system. Analysis the findings (decidability/complexity). Improve the algorithm.
References
- J E Hopcroft and J E Ullman.
- Introduction to Automata Theory, Languages and Computation. Addison-Wesley (1979).
-
Supervisor:
Artur Boronat (ab373)
Prerequisites
A good understanding of OO-programming.
Aims of Project
Software artifacts in industrial applications can consist of thousands of code files. To enhance software maintenance of such applications techniques to abstract essential information from code are crucial. The aim of the project is to define a graphical visualizer for representing java or c# code files (classes) and their relationships (references between classes). Zoom facilities should be provided in order to hide/add information: encapsulate clusters of highly cohesive classes (classes with many references among them), isolated nodes, etc.
Either .NET or java technology can be used.
Challenges presented by the project
The challenges of this project can be found in the following areas:
- graphical representation techniques
- code parsers
- code representation
- algorithm for zooming
Learning Outcomes
The student will:
- carry out a detailed requirements analysis and specification of the problem.
- produce an objected-oriented design of a software system to implement
- learn about human computer interaction
- learn about visual representation techniques
Nature of End-Product
A graphical editor for representing programs with zoom facilities
Project Timetable
Semester1
- Explore graphical techniques based on .NET or java
- Explore techniques for representing programs: parsers, regular expressions
- Specification, design, implementation and testing of a first prototype
Semester2
- Explore techniques for zooming
- Define algorithm for zooming: decide which information to show/hide
- Complete specification, design, implementation and testing of the prototype
References
-
Supervisor:
Emilio Tuosto (et52)
Prerequisites
This project requires an interest in Web technologies and information
systems
Aims of Project
In 1985 O. Patashnik and L. Lamport created BibTeX in order
to make it easy to consistently cite sources. In BibTeX
bibliographic information is separated from its
presentation. This same principle of separation of content
and presentation/style is present in many other languages
like LaTeX, XHTML and CSS, etc.
The project is to design and implement a Web-based system to
assist users to find and keep updated a bibliographic system
based on the BibTeX format. In particular, the system should
help authorised users to search a database of bibliographic
entries and to help users in updating the database. The
system will be implemented Java or PHP, and XML.
Challenges presented by the project
The minimum challenges on this project include translating (a)
existing formats for databases of bibliographic references
(e.g., bibtex, xml), (b) produce a system easily accessible
and manageable from the web.
Learning Outcomes
- Produce the requirements specification for the system.
- Solve the concurrency problem by producing an algorithm for updating the database.
- Design and implement the system.
- Produce a user interface, produce the project report.
Nature of End-Product
A Web-based system for managing a bibliographic database.
Project Timetable
Semester1
Review Information Systems, learn the basics of programming
languages needed; produce the set of requirement; design the
database component and the user interface.
Semester2
Implement the system and the user interface; write up project report.
References
- L. Lamport.
- LaTeX: A Document Preparation System. Addison-Wesley. (1986).
- T. Connolly, C. Begg and A. Strachan.
- Database Systems.. Addison-Wesley. (2003).
![[University Home]](/images/unihome.gif){kind=small}
|![[Faculty of Science]](/images/fac_of_science.gif){kind=small}
|![[MCS Home]](/images/schhome.gif){kind=small}
|![[CS Home]](/images/depthome.gif){kind=small}
|
|![[University Index A-Z]](/images/index.gif){kind=small}
|![[University Search]](/images/search.gif){kind=small}
|![[University Help]](/images/help.gif){kind=small}
|