Project Ideas

If you are a IT/CompSci student looking for an interesting project for your thesis, why not consider one of the following? We’d be very glad to help you (and your supervisor) with any points arising.

A bit of background (if you've just landed here via google)...

Apache Isis 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; Apache Isis 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.

There are also some project ideas in our JIRA, labelled GSOC (for the annual Google Summer of Code).

Maven plugin

Apache Isis 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.

Apache Isis 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 Apache Isis 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.

Scala Domain Models

Apache Isis 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 Apache Isis 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.

Update: 2010-10: Manchester University, UK, have indicated that one of their students may be working on this.

Mashup Views

One of the limitations of Apache Isis 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 Apache Isis 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.

Composite Views

One of the limitations of Apache Isis 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 Apache Isis 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.

JavaFX viewer

Apache Isis 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 Apache Isis 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 Apache Isis using JavaFX.

_This is a large project, but could be of interest to anyone who likes developing sexy-looking UIs in fancy technologies. Isis 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. See UserStoriesForWritingAViewer for further guidance. _

Update: 2010-10: Birmingham University, UK, have indicated that one of their students may be working on this.

GWT viewer

Apache Isis 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 Apache Isis ships with a rich client viewer (implemented in Java AWT) and a simple HTML viewer for deployment on the web.

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 Apache Isis 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 above, 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. See UserStoriesForWritingAViewer for further guidance.

Multi-touch (Android) viewer

Apache Isis 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 Apache Isis ships with a rich client viewer (implemented in Java AWT) and a simple HTML viewer for deployment on the web.

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 Apache Isis 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. See UserStoriesForWritingAViewer for further guidance.

Update: 2010-08: Birmingham University, UK, have indicated that one of their students HAS worked on this (I haven't yet seen the results of that work). A member of the Isis community is also considering working on an Android viewer.

NoSQL/Cloud-based Persistence Stores

Apache Isis 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 Apache Isis 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 Apache Isis that uses a NoSQL object store.

This is a medium sized project. Possible technologies incude 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.

IDE Support for Domain Models

Apache Isis 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, Apache Isis 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 “Apache Isis programming model”.

This project is to provide IDE tooling to support the Apache Isis 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. Either that project could be resurrected, or start afresh. Alternatively, they might want to write plugins for NetBeans or IntelliJ are also options since both freely available.

IDE UML Tooling for Domain Models

Apache Isis 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 Apache Isis 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 Apache Isis 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. 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.

BDD Testing

Apache Isis 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; Apache Isis 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 Apache Isis provides support for testing in two ways. Firstly, the developer can write JUnit tests; however these can’t be shown to a domain expert for her to validate. So as an alternative, the BDD viewer provides an integration with Concordion.

Concordion is a relatively new story-based testing framework that allows story tests to be written in HTML. This also allows them to have plenty of context (diagrams etc) within them so that they make sense to the domain expert. The developer 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.

There are though a number of other BDD frameworks out there, such as Cuke4Duke (a port of Ruby's Cucumber BDD framework). This project, then, is to provide a port of the existing BDD testing framework for Apache Isis.

This is a small project; a lot of the required infrastructure already exists for the Concordion support

Story Recorder

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. The question is: how to write these tests?

Because Apache Isis 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 Apache Isis does already have this capability, writing out to XML.

Story Writer

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. The question is: how to write these tests?

Apache Isis works its magic by building a metamodel; the viewers then interrogate this metamodel in order to render the domain objects. Apache Isis 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.

iTunes Clone

Because of its focus on the domain model, Apache Isis 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 Apache Isis, 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?

DDD Full-scale Example

Because of its focus on the domain model, Apache Isis 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, Apache Isis 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, though.