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.

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. In this paper, we describe how we have introduced students to DevOps practices early in their degree programme, and then woven their use through many different projects as an underpinning thread. Rather than being taught in isolation, these professional practical skills are practised repeatedly through the degree, in different contexts, to the point where they almost become second nature. We describe concretely the structure of our introductory DevOps Lab exercise and how it is assessed, explain how DevOps skills are applied in later projects, and report on our experience so far of teaching these techniques in this manner.

We present Diggit, a tool to automatically generate code review comments, offering design guidance on prospective changes, based on insights gained from mining historical changes in source code repositories. We describe how the tool was built and tuned for use in practice as we integrated Diggit into the working processes of an industrial development team. We focus on the developer experience, the constraints that had to be met in adapting academic research to produce a tool that was useful to developers, and the effectiveness of the results in practice.

Amazon Web Services unveiled their "Lambda" platform in late 2014. Since then, each of the major cloud computing infrastructure providers has released services supporting a similar style of deployment and operation, where rather than deploying and running monolithic services, or dedicated virtual machines, users are able to deploy individual functions, and pay only for the time that their code is actually executing. These technologies are gathered together under the marketing term "serverless" and the providers suggest that they have the potential to significantly change how client/server applications are designed, developed and operated.

We present a tool that provides effective graphical animations as a means of validating both goals and software designs. Goals are objectives that a system is expected to meet. They are decomposed until they can be represented as fluents. Animations are specified in terms of fluents and driven by behaviour models.

A fundamental part of a Computer Science degree is learning to program. Rather than starting students on a full commercial language, we favour using a dedicated "teaching language" to introduce programming concepts.At the same time, we want to introduce students to popular tools that assist in the software development process. However, up until now our teaching language, Kenya, has not been supported by professional IDEs. Therefore, we have been unable to progress smoothly from first principles to the state of the art within one environment.We present work that integrates the Kenya language into the Eclipse environment. Students can now become familiar with the major features of a professional IDE while learning to program, and experience a smooth transition to commercial languages within the same environment.One of the hardest things to teach students is good programming style. Compilers reveal syntactic and type errors, but do not analyse style. We have harnessed as-you-type code checking, as seen in Eclipse's Java development tools, to provide advice on program style as well as correctness.

Constructing rigorous models for analysing the behaviour of concurrent and distributed systems is a complex task. Our aim is to facilitate model construction. Scenarios provide simple, intuitive, example based descriptions of the behaviour of component instances in the context of a simplified architecture instance. The specific architecture instance is generally chosen to provide sufficient context to indicate the expected behaviour of particular instances of component types to be used in the real system. Existing synthesis techniques provide mechanisms for building behaviour models for these simplified and specific architectural settings. However, the behaviour models required are those for the full generality of the system architecture, and not the simplified architecture used for scenarios. In this paper we exploit architectural information in the context of behaviour model synthesis from scenarios. Software architecture descriptions give the necessary contextual information so that component instance behaviour can be generalised to component type behaviour. Furthermore, architecture description languages can be used to describe the complex architectures in which the generalised behaviours need to be instantiated. Thus, architectural information used in conjunction with scenario-based model synthesis can support both model construction and elaboration, where the behaviour derived from simple architecture fragments can be instantiated in more complex ones.