/dev/journal: We just finished week 6 of ASEP, the ‘Advanced Software Engineering Practices’ course we teach at the School of Computing Science at the University of Glasgow. This is the 6th year we’re teaching this particular course, so I figured this would be a good time to talk a little bit more about it.

We (the Glasgow branch of JPMorgan Global Technology first started teaching at the University of Glasgow in 2014, teaching a course called “Software Engineering for Financial Services” (SEFS). This collaboration came about as the School of Computing Science was keen to get more industry involvement in their courses, and we were keen to get more “industry-relevant” practices taught at the University level to ease the graduates’ transition into real work.

I took over running the course in 2016 and renamed it ‘Advanced Software Engineering Practices’ to give a clearer focus on the practices aspect, and to remove the implication that these practices are somehow unique to the financial services industry. Calling it ‘advanced’ practices is a bit of a stretch (“contemporary” would perhaps be a better term), but in the context of all the other courses taught at University level, I suppose “advanced” could be forgiven. In practice, the course is now half-n-half “agile” and “XP”, with some team-theory and coaching thrown in to round it off. A requirement for the course is to have completed an internship (~10 weeks) or industry placement (~12 months), as this gives us the opportunity to relate our teaching back to what the students experienced during their time in industry.

Course Overview

Unique to the course is that our students (a mix of 4th year BSc (Hons) and MSci) also act as hands-on team mentors for the 3rd year BSc team-project teams. This gives them an opportunity to apply what they learn on the course, and to implement two “Practice Improvement Plans” with their team. They do a warm-up exercise during 1st term and get feedback on it from us, and then a second, larger exercise during 2nd term that forms part of their assessed work for the course.

The course is taught during 10 weeks of semester 1, each week consisting of a 2-hour seminar (mostly spent in smaller break-out groups, each facilitated by a JPMorgan coach), a 1-hour lecture (given by one of us from the JPMorgan team), and a 1-hour stint in the 3rd year team-project lab. During the pandemic (2020 and 2021), we’ve done all seminars and lectures via Zoom.

Team Skills

We cover creative skills such as brainstorming, using the Eureka Ranch mindmapping exercises to draw out questions and misconceptions from the students’ own team-project and internship experiences. We also cover Tuckman’s team-theory (forming-storming-etc.), along with some of the corresponding management and leadership theories like the Hersey-Blanchard situational leadership model. And to round off the interpersonal skills section, we do a quick survey of the various models for reasoning about personality traits (MBTI bad, Big Five better, personality “clusters” based on Big Five best).

We also do a brief introduction to systems thinking, covering the iceberg model of influencing behaviour, and some simple causal-loop diagrams. One of the most fun exercises we do is based on this “Why do meetings start late?” article by Sandor Schuman.

And finally we do an Improvement Clinic where the students get a chance to present their ideas for their warm-up improvement exercise to each other and get feedback and ideas from peers and coaches.


Under our Agility banner, we give a summary of waterfall for context, and then compare and contrast with current agile approaches, mostly based on Scrum and Kanban. We discuss the difference between iterative and incremental development, we look at what quality means in the context of software engineering, and we do a deep-dive on the most important of all the agile practices: the retrospective.

With input from the students, we also look at agile anti-patterns - where they come from, how to identify them, and ways of bringing them back in line with the goals of agile.

And we look at where agile is going, at DevOps, DevSecOps, and the underlying patterns driving the change.


We cover a mix of practices, starting with product based ones like filling in a Value Proposition Canvas to flesh out product ideas and Design Studio to rapidly explore design ideas for user-interfaces, etc.

Our experience bringing graduates into the organisation has highlighted the differences between the Uni experience and how we work in industry, and one of the biggest differences is the emphasis Uni work puts on individual delivery compared to how we usually work together in teams. To give our students some experience of this, we give them an opportunity to experience ensemble programming (both the pair- and mob-variations) and stress the importance of Llewellyn Falco’s strong-style pairing to get away from the idea that pairing is merely “two people working at a single computer”. We also practice a few different collaboration techniques, most notably ping-pong TDD.

Speaking of TDD, we cover Test-Driven Development in detail as a separate practice, and also in the context of refactoring and working with legacy code.

Legacy code is also part of our “at Scale” discussions where we look at the practices and techniques that help us work in bigger teams, on larger code-bases, that are maintained over longer life-cycles than anything our students are likely to have experienced in University. Part of this is tooling, part of it covers patterns and conventions, and part of it is practices.

Finally, we round off our practices topic by looking at distributed systems architectures in particular, and deployment topologies in general, before finishing off with a hands-on cybersecurity exercise. This usually involves doing an adversarial threat-analysis and -mitigation of a hypothetical system (we even did one on the defense of Minas Tirith).

Industry Panel

During the last lecture of the course, we give the students a chance to turn the tables on us, and ask questions of a diverse panel of industry representatives. The idea behind the panel is mostly to reinforce for the students that these techniques and practices we’ve been teaching them for the 10 weeks of the course are not specific to our company, or even our financial-services niche of the industry, but rather common to all of software engineering. It is also an opportunity for the panellists to offer alternative views and to share their experience of working in the industry so that the students know better what to expect after graduation.

Which brings me to the purpose of this recap. Would you like to join our panel? Either this year (30-Nov-2021, 4pm GMT) or in the future?. (You can also DM me on Twitter, or drop me an email - details are in the website-footer.)