The University of Cambridge provides world class Computer Science courses. Stephen works as a Computer Science supervisor (mostly for Churchill College) and this page describes his work from his perspective.

Operating Systems

Years supervised: 2012/2013, 2013/2014, 2014/2015, 2015/2016 (will also be supervising for 2016/2017)

My most supervised course (5 years in a row), this is a first year course that goes through the basic details of operating systems, including:

  • Kernel design: Microkernel vs Monolithic
  • Scheduling algorithms
  • Paging, page tables, page replacement, etc.
  • I/O
  • File systems
  • Linux and Windows case studies (Windows returned as a case study last year)

C and C++

Years supervised: 2012/2013, 2013/2014, 2014/2015 (will also be supervising for 2016/2017)

This course goes through the key details of the C and C++ programming languages. I really like this course but it’s a difficult one for the students (C and C++ are complex); the recommended number of supervisions was recently increased to reflect this.


Years supervised: 2014/2015

Prolog is a very interesting programming language because it expresses programs declaratively (describing what needs to be done to compute the result) rather than imperatively (describing how to compute the result). Here’s an example of a routine to concatenate two lists:

concat([], L, L).
concat([H|T], L, [H|R]) :- concat(T, L, R).

In an imperative language it might look something like:

concat(A, B):
	new_list = B
	for element in reversed(A):
		new_list = [element | new_list]
	return new_list

The course focuses on how Prolog is evaluated, since this is needed to understand the ‘cut’ operator (which prevents backtracking) and structures such as difference lists.

Complexity Theory

Years supervised: 2014/2015

Computational problems can be put into groups depending on how long it takes to solve them. For example, P is defined as the set of all decision problems (i.e. problems with a yes/no answer) that can be solved in a polynomial number of steps (O(N^X) where N is related to the input size and X is a constant) on a deterministic Turing machine.

Complexity theory defines many of these sets, such as P, NP, NP-hard etc. and attempts to answer questions like the famous open problem of whether P = NP.

The course shows that different problems are actually related to each other through the conversions used and also suggesting that some common problems may require exponential time (in practice these problems are usually solved by faster algorithms that are very good but not optimal).

Compiler Construction

Years supervised: 2014/2015

Compilers are important tools and deploy a lot of theory, including:

  • Regular expressions in the lexer
  • Context-free grammars in the parser
  • Flow analysis in the optimiser
  • Graph colouring in the register allocator
  • etc.

This course covers how to get from source code to machine code mostly without worrying about optimisation (that’s covered by the third year course ‘Optimising Compilers’).

Numeric Methods

Will be supervising for 2016/2017