Publications

Teaching modern software engineering requires balancing authentic industry practices with accessibility for students. Cloud platforms like AWS and Azure are powerful but can be overly complex for educational contexts. To address this, we developed an internal Platform-as-a-Service (PaaS) using the open-source Tsuru platform. This solution simplifies deployment, enabling students to focus on building and iterating on applications without the need for direct interaction with complex cloud infrastructure, and facilitates administration and access for instructors to support the learning experience. This paper presents our experiences using this platform in software engineering courses. We discuss challenges, lessons learned, and practical advice for educators aiming to create similar solutions to support student learning.

Software engineering education is often detached from real-world practices: demonstrations and exercises are limited in scope and fail to capture the complexities and architectures found in industrial projects. Smaller tasks might not demand effective software design so students may neglect these principles in projects. We present a contextualized learning approach to software engineering education: within our Computer Science department, we develop bespoke software to support teaching and learning with source code made open to student contributions, following open-source software practices. This philosophy enables the use of our code in lectures as real-world examples and allows students to directly shape the evolution of software they use daily, both through occasional contributions and broader internship-like summer projects. These initiatives combine theory and practice so students can experience software evolution, maintenance, and collaboration first-hand in a meaningful context. Our experience could assist other institutions seeking to provide authentic, practical experiences in software engineering.

Timely and specific formative feedback is essential for quality education but challenging to scale for large cohorts. This paper presents Lambda Feedback, a digital platform providing automated real-time feedback to students on self-study. Deployed across multiple disciplines, it supports diverse question types, including symbolic mathematics. Teachers configure feedback without ‘coding’. Feedback is provided by an external ‘microservice’, enabling anyone in the community to develop feedback technology that can plugin to the platform. User surveys show a positive effect on learning experiences. Currently a work-in-progress, the platform provides feedback a million times annually in total. Future work will expand feedback functionality and scale to one million feedback events per cohort per year, i.e. billions per institution per year.

We present the design and evolution of a project-based course – Designing for Real People – that aims to teach agile software development through an unwavering focus on the user, rather than emphasising the processes and tools often associated with a method like Scrum. This module is the result of a fruitful collaboration between a Computer Science Department, bringing knowledge and skills in the software engineering aspects, and the Service Design group of a neighbouring Art College, with expertise in user research and user experience design.We present the details of the current structure, content and assessment strategies developed for the module, as well as the principles behind its design. The core theme of the course is gathering and responding to feedback, and so here we present how this has been applied to the design of the module itself, with lessons learned, and improvements made over time. By reflecting on our own work, we aim to provide recommendations that may aid others considering how to teach these topics.

Due to globalization, many software projects have become large-scale and distributed tasks that require software engineers to learn and apply techniques for distributed requirements analysis, modeling, development, and deployment. Globally-distributed projects require special skills in communication across different locations and time zones in all stages of the project. There has been advancement in teaching these concepts at universities, but adapting global software engineering in a curriculum is still in infancy.The main reasons are the effort and coordination required by teachers to set up the project, manage distributed development and enable distributed delivery. It becomes even more difficult when teaching distributed software engineering involving Internet of Things (IoT) applications. The situation has changed with recent advances in continuous deployment and cloud platform services that make globally-distributed projects more feasible, teachable, and learnable, even for short-term projects. However, no experience report in education research describes a truly distributed global setup in continuous software engineering for IoT applications.This paper describes a ten-day project involving three universities in different countries with 21 students located across the world to substantiate this claim. It provides teachers with recommendations for conducting a global software engineering course in a global setting. Recommendations include access for all students to (remote) hardware, stable network infrastructure in all locations, the use of a central development platform for continuous integration and deployment, and the application of distributed pair deployment.

In preparing students for a future career as software engineers, in addition to learning the fundamentals of Computer Science, we want them to develop a set of practical skills and professional ways of working. Current industry trends are towards the adoption of a DevOps culture, where software engineers are responsible not only for the design and development of software systems, but also for their deployment and operation in production...

Building a programme of education that reflects and keeps pace with industrial practice is difficult. We often hear of a skills shortage in the software industry, and the gap between what people are taught in university and the 'real world'. This paper is a case study showing how we have developed a programme at Imperial College London that bridges this gap, providing students with relevant skills for industrial software engineering careers. We give details of the structure and evolution of the programme, which is centred on the tools, techniques and issues that feature in the everyday life of a professional developer working in a modern team. We also show how aligning our teaching methods with the principles of lean software delivery has enabled us to provide sustained high quality learning experiences. The contributions of this paper take the form of lessons learnt, which may be seen as recommendations for others looking to evolve their own teaching structures and methods.