Right now, this is an outline of our plans and existing syllabus. But the content and exercises will appear here soon too.


On campus, we teach the course with live demo/lectures, studio time, peer reviews, and a lot of cloud online tools. Last year's teaching content is still online, though the system is undergoing some changes.


The course is designed around the projects, which take place in the cloud on various services.

It also means the teaching software will need to support groups and group collaboration.



We're planning two kinds of video:

Conceptual videos that can be reused across languages and toolsets (in a presenter style or voice-over-animation).

Screen recordings and demos specific to lanugages and tools.


In-place exercises

Small exercises will be interspersed with the videos. Many will require the student to do something off-line in a real tool, and come back to answer the question.

For example, find who committed the password into the git repository, and whether it's still there.


Outside exercises

There are many good online resources for software engineering concepts, including a number of live-in-browser exercises.


Social content

The class itself needs to be able to share social content, and we'd like to treat that as being as important as the content we write.

We've been writing a little social interactive/teaching tool to support this in-class, which we'd need to replace or expand.



Students will regularly critique work by other teams on the same codebase.

We've been writing a little review tool to support this in-class, which we'd need to expand or replace.


First Three weeks

At the start of the course, we give the teams a small amount of code (setting up a project structure), and a mission. The students need to get and understand the code, and understand how to contribute changes to it. And that means there's a little bit of individual work before the project begins.

Distributed version control

The videos and exerises take this from first principles, to very quickly give you a working knowledge

Continuous integration

Automated build systems

(2013 slides)

Exploring code

In 2013 this was done as a live demo.

Test driven development

The project

At the end of week 3, teams form and the project begins. From this point on, the course material is to help improve how you students work on the project.

Please bear with us as I keep transferring the syllabus from our last iteration across to this site...

Ticket management

Code smells

Making code testable

Whiteboard UML

Design Patterns


Database patterns



Metrics and static analysis

Project endgame

As we enter the last couple of weeks, the teaching content is unlikely to make its way into the student projects (because they're almost finished). So we focus on more general topics that might feed into future projects.

Memory and garbage collection

Looking inside the VM using VisualVM

JVM and bytecode

On campus, we teach the course in Java, which gives us great tooling to watch how the code is optimised.


The students' project has no live customers, so never faces performance issues. But here we start to look at how to debug performance

Immutable data and functional programming principles

Even in an imperative language, we find it valuable to teach about immutable data, thread-safety, futures, and monads.

Critiques and demo

As the project progresses, there will be a number of studio style peer critiques. We find these are valuable both for the subject (receiving feedback) and the critic (learning from looking at others' work).

In 2013, there was a mid-point critique, and a final demo day. In 2014, we're increasing the number of critiques.

We'll also be maintaining a social stream where students and groups can post useful content into the course while it runs.