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.
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.
There are many good online resources for software engineering concepts, including a number of live-in-browser exercises.
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.
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.
The videos and exerises take this from first principles, to very quickly give you a working knowledge
Why collaborative coding is more than just a matter of synchronising the files.
(Ticket) (Script) (2013 slides)
(Screen recording for git) (Screen recording for sourcetree)
(Exercise - who leaked the password)
(Ticket) (Script) (2013 slides)
(Screen recording for git) (Screen recording for sourcetree)
(Exercise - who made it lie)
(Ticket) (Script) (2013 slides)
(Screen recording for git)
(Exercise - backport the fix)
(Ticket) (Script) (2013 slides)
(Screen recording for git) (Screen recording for sourcetree)
(Exercise - sabotage)
(Ticket) (Script) (2013 slides)
(Screen recording for git) (Screen recording for sourcetree)
(Exercise - pass the parcel)
(Ticket) (Script) (2013 slides)
(Ticket) (Script) (2013 slides)
(Screen recording for git) (Screen recording for sourcetree)
(Exercise - who leaked the password)
In 2013 this was done as a live demo.
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...
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.
Looking inside the VM using VisualVM
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
Even in an imperative language, we find it valuable to teach about immutable data, thread-safety, futures, and monads.
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.