Software Engineering II (SENG301)

This is the second course on software engineering after students learned about more classical development processes, software modelling and object orientation. This lecture-based course is composed by two distinct parts. I share the duty with another colleague and I mainly focus on the software development aspects (e.g., processes, team work, quality assessment). The first half is about teaching the Agile Software Development philosophy, un-teaching it and re-teaching it again. My colleague focuses on (object oriented) implementation aspects such as design patterns and advanced OO principles (e.g., Liskov, contracts).

In my first half of the course, I teach about:

• The Agile manifesto, its principles and how these should shape a particular software development process.

• The Scrum software development method, its roles, events and values. Students play with the method in immersive tutorials where they build a city out of craft paper over multiple short sprints.

• Continuous integration and deployment, including automated acceptance testing (using Cucumber), staged testing, proper versioning and how to ensure the quality of a product (e.g., branching, code review, mocking).

• A series of introductions to work ethics, resilience engineering, user experience (including basic UI design principles) and knowledge management.

The course material also includes weekly readings from grey literature sources (e.g., blogs) to complement the course material with an industrial touch. More details available on the official course page.

Software Engineering Group Project (SENG302)

This course is very different from a typical lecture-based teaching experience. Few lecture sessions are organised and the students are put in teams where they are immersed in a industry-like project. Every 3 to 4 weeks, teams deliver a shippable product that they demonstrate and review with the product owner and other teams. Technical workshops are organised to teach about continuous integration (and a little bit of DevOps), code review and unit and automated acceptance testing (including Test-Driven Design).

During a sprint (name for a Scrum iteration), each team needs to negotiate their sprint backlog with the product owner and must implement all other classic Scrum event (i.e. standups, retrospective, plannings). They also practice continuous integration and deployment practices where they need to automatically deploy on a dedicated server, keeping static code analysis tools happy together with good automated (and manual) testing indicators.

As the year goes, teams are usually encouraged to tweak their product with their own vision to differentiate themselves from the other teams to incorporate more craft and creativity to the course (after the students have practiced their other more “classical” software engineering skills).

Additionally to formal retrospectives, each team member must reflect individually and about their teammates in self- and peer-reflection after each sprint.

More details available on the official course page.

Software Engineering Research Project (SENG402)

This course is the capstone project for software engineering students. Students must work individually on either a staff or sponsored project that includes some aspects of research (e.g., user study, application of latest research results in an industrial context, proof-of-concepts). Students are supervised by an academic staff member and, when relevant, by an industry sponsor. Students deliver a project plan, an interim and a final report on top of a public presentation and a formal demonstration.

This project is the opportunity for students to dig into a challenging problem and lead a software engineering project by themselves. More details available on the official course page.

Model-Driven Software Engineering (SENG405)

The purpose of this course is to introduce students to model-driven software engineering practices. Students learn about appropriate methodologies and suitable tooling support for model-driven software engineering. Then, they develop team work skills as software language engineers where they will create their own software language and implement a dedicated development environment. Last, they conduct an empirical evaluation of a domain specific language framework developed by their peers.

The course use a mix of theoretical lectures and practical labs (e.g., using Arduinos). More details available on the official course page.

Sadly, this course is discontinuated for now as we are missing enough resources and I’ve taken over the software security course (more to come on that soon).

Software Security

Building secure software is an intricate task that involves careful design of both preemptive and corrective measures. This course covers the secure development lifecycle where students learn about techniques to model security threats, follow secure coding standards and perform security-focused testing to prevent software to expose vulnerabilities. Students learn how to combine tools of various natures to identify threats as part of a continuous integration pipeline. The course also addresses data privacy and governance issues, including (indigenous) data sovereignty principles.

The course is dedicated to fourth year students with an experimental (audit of open source software) and research focus (literature review of latest advances in security). More details available on the official course page.

Professional Master of Computer Science

I also contribute to the software architecture, design and continuous integration component of the bootcamp of the Professional Master in Computer Science. I teach three full days in that two week compressed module where computer science students get up to speed with software engineering practices including, on top of above topics, agile software development and requirement engineering.