Final year and Advanced MSc project topics for 2010-11

The following Software Engineering projects are mostly related to Unified Modelling Language (UML), Automated Software Engineering, Model Driven Development, Service oriented Architecture and code generation. Most projects are suitable for both Undergraduate students and Advanced MSc students. Advanced versions of the following projects will directly contribute to the ongoing research projects within my team or with other colleagues and are expected to result in scientific publications. To learn more about each of these projects pop in to my office or email me B.Bordbar@cs.bham.ac.uk.

Model Driven Development

The Model Driven Architecture (MDA) and Model Driven Development (MDD) are very popular emerging technologies for software development. MDA/MDD promotes the automatic creation of models and code by a series of transformations.You can learn about the MDA in www.omg.org/mda/ or by checking Wikepedia.

Project 1: Developing software by Model Driven Development. This is a golden opportunity to learn about MDD and Model Transformation Frameworks to learn develop software in Service oriented Architecture (SOA), Web service technology and Embedded Systems. The following are examples of Model Transformation Frameworks

OpenArchitectureWare
KerMeta
Xactium
and our very own Simple Transformer (SiTra)

Project 2: Further development of SiTra. This is a challenging project leading to further development of the tool set SiTra for better testing, analysis, automated code generation. The project is suitable for students with good programming skills in Java, C# or SmallTalk.

Modelling of faults and fault detection in Service oriented Architectures

This project will be supervised in collaboration with Dr Dearden and his team. The idea is to model failure scenarios in SoA and use Livingston to monitor the services for identifying occurrence of failure. The approach aims to deal with real-world fault detection within telecom systems.

Process Mining

Execution of business processes in a service oriented environment is often captured via a set of log files which are kept in geographically dispersed locations. Process mining aims at producing tools and algorithms for re-creating models of abusiveness processes from the log files. The created models can be used for identifying if the system is implemented correctly and for performance tuning.

UML2Alloy and SAT-solving related tools

UML2Alloy is a software developed by our team in Birmingham aiming to bridge the gap between analysis and design of systems.

Project 1: Systems verification, testing and integration via UML2Alloy. UML2Alloy has been used for the Analysis and testing in various application domains. The aim of this project is to use it further to explore industrial applications related to automated testing of software, Security and Quality of Service.

Project 2: Further development of UML2Alloy. To add extra capabilities to UML2Alloy.

Project 3: Modelling with Alloy and problem solving via SAT-solvers. If you are not a very good programmers (some programming skills required) these sets of projects might be of interest.

Domain Specific Languages for Cloud

Following the success of an advanced MSc project on creating DSL for Cloud, this project will further extend the tool. If you haven't heard of the DSL a good place to start is either from the Wikepedia or read a nice article form by Juha-Pekka Tolvanen.

Web Service

Projects 1: development and evaluation of large Web services via IBM Websphere or Oracle JDeveloper. (Only undergraduates)

Asset management systems

Project 1: Academic publication management systems. The aim of this project is to develop a system for the use of academic researchers (including myself!) to search archives of papers and articles kept as PDF files. Knowledge of database systems and good programming skills required. You will be introduced to embedded databases technology and management of PDF files. (Only undergraduates)

Naked object (joint supervision with Dan Haywood)

You can learn about the Naked object at nakedobjects.org.

Project 1:Maven plugin: Naked Objects is a full-stack, open source Java framework for building enterprise apps. The twist is that you do this just by writing the domain objects that sit in the domain model; Naked Objects takes care of the UI and persistence layers for you, creating a generic OO UI at runtime. This can run either as a rich client, or on the web.

Naked Objects works its magic by building a metamodel; the viewers then interrogate this metamodel in order to render the domain objects. This metamodel captures semantics intrinsic to the domain (such as whether a property or action is enabled or not) along with some semantics about the UI layer.

Naked Objects applications are typically built using Maven, the most commonly used open source build tool. Maven itself is a highly extensible build platform. This project is to develop a plugin for Maven that will validate the Naked Objects metamodel. This allows semantic contradictions in the metamodel (such as saying a property is both visible and not visible at the same time) during the build phase, allowing such errors to be rapidly fixed.

This is a small project; of interest to those who understand how important good configuration management and build management is. Would need a fairly technical person who is able to pick through Maven open source code to figure out how to write plugins.

Project 2:Scala Domain Models. Naked Objects is a full-stack, open source Java framework for building enterprise apps. The twist is that you do this just by writing the domain objects that sit in the domain model; Naked Objects takes care of the UI and persistence layers for you, creating a generic OO UI at runtime. This can run either as a rich client, or on the web.

Naked Objects works its magic by building a metamodel; the viewers then interrogate this metamodel in order to render the domain objects. But this "metamodel builder" is extensible, and could be used to support any JVM-based language.

This project will extend Naked Objects to allow enterprise applications to be developed in a relatively new JVM language, Scala. This contains all the power of Java, but incorporates constructs from various functional languages. The end result will be the ability to develop and deploy enterprise applications written in Scala, running either as a rich client app or on the web.

This is actually a pretty small project. It doesn't have to be Scala, of course; other JVM language candidates are Groovy and JRuby. The work involved is amounts to writing a bunch of FacetFactorys. It might appeal to those who want to learn another JVM language.

Project 3:Mashup Views Naked Objects is a full-stack, open source Java framework for building enterprise apps. The twist is that you do this just by writing the domain objects that sit in the domain model; Naked Objects takes care of the UI and persistence layers for you, creating a generic OO UI at runtime. This can run either as a rich client, or on the web.

One of the limitations of Naked Objects out-of-the-box though is that this OO UI is just that, generic. If collection of Appointment objects will just be shown as a list, rather than, say, as a Calendar. Similarly, a collection of CompanyAddresses will also be shown as a list, rather than, say, rendered on a Google Map.

This project will extend Naked Objects web viewer to allow it to support various so-called "mash-up" views, including the Calendar and Google Map views above.

This is a small-ish project. The HTML viewer that comes with NO isn't extensible, but my new Wicket viewer is and would be a good basis for this. Alternatively, the DnD viewer could be extended.

Project 4:Composite Views Naked Objects is a full-stack, open source Java framework for building enterprise apps. The twist is that you do this just by writing the domain objects that sit in the domain model; Naked Objects takes care of the UI and persistence layers for you, creating a generic OO UI at runtime. This can run either as a rich client, or on the web.

One of the limitations of Naked Objects out-of-the-box though is that this OO UI is just that, generic, capable of showing an object, a collection, or an action, but not more complex views such as order/detail or wizards.

This project will extend the Naked Objects web viewer to support a number of these more complex views.

This is another small-ish project. Rick Mugridge [an academic in Auckland, NZ, and the maintainer of the FIT framework] had his students do a similar project on a very early version of NO. This project could, perhaps, be combined with the mashup views project.

Project 5:JavaFX viewer Naked Objects is a full-stack, open source Java framework for building enterprise apps. The twist is that you do this just by writing the domain objects that sit in the domain model; Naked Objects takes care of the UI and persistence layers for you, creating a generic OO UI at runtime.

Naked Objects has an extensible architecture making it straightforward to add new viewers (on the front-end) and persistence stores (on the back-end). Out-of-the-box Naked Objects ships with a rich client viewer (implemented in Java AWT) and a simple HTML viewer for deployment on the web. There are however a number of new and interesting UI technologies, one of which is JavaFX. This promises a much richer set of animations and capabilities.

This project is to develop a new viewer for Naked Objects using JavaFX.

This is a large project, but could be of interest to anyone who likes developing sexy-looking UIs in fancy technologies. NO supports remoting etc, so it's really just a standalone app that happens to be written in JavaFX that links to some Java libraries. One thing that Rick Mugridge did with his students on the composite views was to have them develop a ZUI, zooming in and out of a workspace that showed all instantiated objects. It seems that JavaFX might allow for this sort of thing.

Project 6: GWT viewer Naked Objects is a full-stack, open source Java framework for building enterprise apps. The twist is that you do this just by writing the domain objects that sit in the domain model; Naked Objects takes care of the UI and persistence layers for you, creating a generic OO UI at runtime.

The modern web experience however is much richer than simple HTML-based viewers, being characterized by apps such as Gmail. This project therefore is to develop a new web viewer for Naked Objects using Google's GWT library, allowing Gmail-like applications to be easily developed.

This is a large project. My Wicket viewer would be a good starting point. Although I've mentioned GWT in the project proposal (which hopefully some students will recognize), I actually suggest that it is implemented in Vaadin (formerly called IT Mill Toolkit) that sits on top of GWT and provides a bunch of useful capabilities.

Project 7:Multi-touch (Android) viewer

Naked Objects is a full-stack, open source Java framework for building enterprise apps. The twist is that you do this just by writing the domain objects that sit in the domain model; Naked Objects takes care of the UI and persistence layers for you, creating a generic OO UI at runtime.

Notable by its omission though is any support for mobile devices. Google's Android platform supports Java apps; it also supports multi-touch interactions, opening up the possibility of interesting new ways of manipulating domain objects directly.

This project is to develop a generic viewer for Naked Objects to be deployed onto Android-based mobile devices.

This is a large project, but definitely do-able. In fact, there was a PDA-based student project done with an early version of NO, see http://opensource.erve.vtt.fi/pdaovm/pda-ovm/index.html.

Project 8:NoSQL/Cloud-based Persistence Stores: Naked Objects is a full-stack, open source Java framework for building enterprise apps. The twist is that you do this just by writing the domain objects that sit in the domain model; Naked Objects takes care of the UI and persistence layers for you, creating a generic OO UI at runtime. This can run either as a rich client, or on the web.

Naked Objects has an extensible architecture making it straightforward to add new viewers on the front-end, but also to define new persistence stores for the back. Out-of-the-box Naked Objects supports a variety of object stores including RDBMS', but there is increasing interest in so-called non-relational ('NoSQL' persistence stores.

This project, then, is to develop a new object store implementation for Naked Objects that uses a NoSQL object store.

This is a medium sized project. I don't know enough about NoSQL to offer much advice (I'm firmly an RDBMS man myself), but possibilities are db40, prevayler, or Hadoop. Another API I noticed is JClouds, that front-ends Amazon's EC2 and so forth. That actually might be trivial to get working.

Project 9: IDE Support for Domain Models Naked Objects is a full-stack, open source Java framework for building enterprise apps. The twist is that you do this just by writing the domain objects that sit in the domain model; Naked Objects takes care of the UI and persistence layers for you, creating a generic OO UI at runtime. This can run either as a rich client, or on the web.

Naked Objects works its magic by building a metamodel of the Java code, where the Java code is POJO-based, along with a number of "convention over configuration" extensions. For example, Naked Objects detects that a Customer has a firstName property by the presence of a getFirstName() / setFirstName() pair. But it also notices methods such as disableFirstName(), hideFirstName() and other supporting methods, that are used to capture imperative business rules. Collectively this set of conventions is called the "Naked Objects programming model".

This project is to provide IDE tooling to support the Naked Objects programming model, for example so that a rename refactor of a property will also update the supporting methods.

This is a small-to-medium-sized project. I've just listed one example, but it could go much further. For example, a view could be provided showing all properties/collections in a list. Moving these up and down would adjust the @MemberOrder annotation. Or, a view could be used to allow annotations to be applied using checkboxes. I have in fact done some work on this for Eclipse 3.3, but the project was mothballed while I wrote my book. A student could either resurrect that project, or they could start afresh. Alternatively, they might want to write plugins for NetBeans or IntelliJ are also options since both freely available.

Project 10: IDE UML Tooling for Domain Models Naked Objects is a full-stack, open source Java framework for building enterprise apps. The twist is that you do this just by writing the domain objects that sit in the domain model; Naked Objects takes care of the UI and persistence layers for you, creating a generic OO UI at runtime. This can run either as a rich client, or on the web.

Naked Objects works its magic by building a metamodel of the Java code, where the Java code is POJO-based, along with a number of "convention over configuration" extensions. Generally speaking a domain model implemented in Naked Objects is very clean.

Still, a picture tells a thousand words, and a UML class diagram can be a powerful way of understanding the entities involved in a domain model. This project is therefore to provide a plugin for an IDE to render a Naked Objects domain model as a UML class diagram. Initially the project will focus on generating a read-only view; if time then this will be enhanced to be read/write (ie to modify the code through the diagram).

This is a large-ish project. Of course, there are commercial tools out there (such as Omondo, AgileJ and TogetherJ) that do this, and I admit to being a one-time fan of TogetherJ (I co-wrote a book on it). But it'd be nice to be able to pick up and render the NO-specific conventions (eg render hidden properties differently from disabled properties). The project could be descoped by having it simply take an existing UML tool and extend it. And/or, the project could be combined with the previous one, to provide general-purpose IDE tooling.

Project 11: Concordion Testing Naked Objects is a full-stack, open source Java framework for building enterprise apps. The twist is that you do this just by writing the domain objects that sit in the domain model; Naked Objects takes care of the UI and persistence layers for you, creating a generic OO UI at runtime. This can run either as a rich client, or on the web.

The fact that the UI is taken care of automatically makes it very easy to put together enterprise applications, focusing only on the bit that matters: the domain model. In fact, it becomes possible to pair-program directly with a non-technical domain expert, the domain expert identifying the business rules and the developer implementing them directly.

However, this isn't enough for enterprise apps; we also need a set of tests that define the behaviour of the system independently from the code. These become the documentation for the system, and provide a safety net for regression testing.

Out-of-the-box Naked Objects does not provide much support for testing. It is easy enough to write developer-level JUnit tests, but these can't be shown to a domain expert for her to validate. There is a sister open source project that provides FitNesse testing, and that works well, but FitNesse isn't to everyone's taste, and integrates poorly with source code management tools.

A relatively new story-based testing framework is Concordion. This allows story tests to be written in HTML, so can have plenty of context (diagrams etc) within them so that they make sense to the domain expert. The developer then annotates the HTML, using the information within it to drive the underlying system. From a technical standpoint, Concordion is just a JUnit-based framework that happens to get the input from HTML rather than Java.

This project, then, is to provide a Concordion-based testing framework for Naked Objects. This will allow the domain expert/developer to capture the business rules as they are identified in HTML as well as the code; once the programming session is done the developer can then wire up those tests afterwards to provide the regression suite.

This is a small/medium sized project. One slight issue is that I may implement it myself...

Project 12:Story Recorder Naked Objects is a full-stack, open source Java framework for building enterprise apps. The twist is that you do this just by writing the domain objects that sit in the domain model; Naked Objects takes care of the UI and persistence layers for you, creating a generic OO UI at runtime. This can run either as a rich client, or on the web.

Because Naked Objects generates the OO UI at runtime, it is in full control of the interactions made from the UI to the domain model. This opens up the possibility of a "record button" that captures those interactions, and then dumps them out for various purposes, eg to code generate a JUnit test, or a FitNesse test, or to capture a defect for replay. It could also, possibly, be used to create a macro-definition device.

This is a small-to-medium sized project. There's obviously an overlap with the Concordion one. The latest .NET version of Naked Objects does already have this capability, writing out to XML. In Ireland we also have something similar; it writes out to FitNesse tests.

Project 13:Story Writer Naked Objects is a full-stack, open source Java framework for building enterprise apps. The twist is that you do this just by writing the domain objects that sit in the domain model; Naked Objects takes care of the UI and persistence layers for you, creating a generic OO UI at runtime. This can run either as a rich client, or on the web.

Naked Objects works its magic by building a metamodel; the viewers then interrogate this metamodel in order to render the domain objects. Naked Objects has an extensible architecture making it straightforward to add new viewers on the front-end, which opens up the possibility of a viewer that's designed to make test writing easy.

This viewer would present the test author with a simplified view of domain objects, and make it easy for the author to make assertions about the state of those objects or on the post-conditions following an interaction. It could also, possibly, launch one of the regular viewers to allow the user to inspect the current state of the system.

Once the test is written, the viewer would allow the test script to be dumped into an external format, eg so it can be converted into a JUnit or FitNesse test.

This is a relatively large project. There's obviously some overlap with the other two testing projects. Again, we have a crude version of this on the Irish project.

Project 14:iTunes Clone Naked Objects is a full-stack, open source Java framework for building enterprise apps. The twist is that you do this just by writing the domain objects that sit in the domain model; Naked Objects takes care of the UI and persistence layers for you, creating a generic OO UI at runtime. This can run either as a rich client, or on the web.

Because of its focus on the domain model, Naked Objects is a natural bed-fellow with domain-driven design. DDD defines a set of patterns that describe how to architect enterprise-apps, with a correct separation of concerns. Part of this is the use of domain services that allow the core business parts of a domain to be separated from technical concerns.

Now we all like to listen to our MP3s, so how about implementing an iTunes clone following DDD principles? There are some nice entities to model (Artist, Album, Genre etc), but there are also some technical concerns that need solving (how to actually play the MP3, how to purchase new tunes off the web). So this project is to implement iTunes from the ground-up, using Naked Objects, and following strict DDD principles.

This is small-to-medium sized. It'll be perhaps more difficult if it is web-based. It could also be extended by bring in some of the composite views of other projects (eg a coverflow viewer). If this application doesn't appeal, then perhaps a Twitter-clone, or Facebook-clone, or any other of those hip and trendy websites?

Project 15: DDD Full-scale Example Naked Objects is a full-stack, open source Java framework for building enterprise apps. The twist is that you do this just by writing the domain objects that sit in the domain model; Naked Objects takes care of the UI and persistence layers for you, creating a generic OO UI at runtime. This can run either as a rich client, or on the web.

Because of its focus on the domain model, Naked Objects is a natural bed-fellow with domain-driven design. DDD defines a set of patterns that describe how to architect enterprise-apps, with a correct separation of concerns. DDD does this by defining the notion of "bounded contexts": a domain model along with its set of stakeholders. DDD then goes further by defining a taxonomy of different BC relationships. A common one in enterprise apps is to use a "published language", decoupling one BC from another.

This project is to develop two relatively simple DDD apps, each in their own BC, and then to demonstrate how they would interact using the "published language" interaction. The first BC is an OrderMgmt app, used to manage Customers and their Orders. The second BC is an InventoryMgmt app, used to manage inventory in the warehouse. When an Order is completed, the OrderMgmt app raises a DomainEvent to this fact. The InventoryMgmt app picks this up, and fulfils the order. It might also raise a purchase order with the supplier if stocks are running low.

In terms of technology, Naked Objects will be used to implement the applications, while an open source enterprise service bus (eg ActiveMQ plus Camel) will be used to route the messages from one BC to another.

This is a small-to-medium sized project (though I guess its scope could grow). It might be a little theoretical for students to follow, though.