University of Oxford Logo University of OxfordSoftware Engineering - Home
On Facebook
Follow us on twitter
Linked in
Linked in
Google plus
Google plus
Stumble Upon
Stumble Upon

Concurrency Oriented Programming

Using concurrency as a building block to implement the next generation of embedded, edge and server side systems will allow them to scale and be resilient. Scalability is achieved vertically on multi-core architectures, and horizontally, in a distributed computing environment abstracting away the underlying network, hardware and operating system layers. It is a technique which can be applied regardless of programming language, requiring a different way to think and reason around your problem.


This course normally runs twice a year.

Course dates

14th July 2025Oxford University Department of Computer Science - Held in the Department10 places remaining.


To help you learn how to think and reason concurrently, we will use Erlang, an open source language that, thanks to its lightweight processes, no shared data, and built-in distribution, caters for these types of problems. It has become an ecosystem of over 30 languages, including Elixir. This course will teach you how to implement highly concurrent, massively scalable soft real-time systems with an emphasis on fault tolerance and high availability, making you a better programmer regardless of what languages you use on a daily basis.


Invent a language to solve a problem, don’t invent a language and then figure out what it is good for.
Basic sequential programming in Erlang:
Looking at the functional aspects of Erlang, including datatypes; pattern-matching; functions, modules and built-in functions (BIFs); guards and recursion.
Concurrent programming:
Creation and lifecycle of processes; sending and receiving messages; selective reception; passing data; time-outs and registering processes.
Process design patterns:
Client-server systems; finite-state machines; event handlers and supervisors; synchronous versus asynchronous message passing.
Process error handling:
Understanding the let it crash philosophy; process links, exit signals, propagation semantics; design patterns for robust systems.
Code updating:
Doing software upgrades at runtime.
Distributed programming:
Requirements of distributed systems; distribution syntax and semantics; naming, visibility and security.
ETS and Dets tables:
Fast data access in the same memory space as the virtual machine. Erlang Term Storage (ETS); guidelines for using tables; table visualisation.
Process Behaviours:
Looking at reusable process behaviour libraries; generic servers; supervisors.


The course requires good programming skills (in any programming language). It will be helpful, but not necessary, to have taken the Functional Programming course first.