We normally have two classes per week, one on Monday and one on Wednesday, both at 10:00–11:45. See below for a more precise schedule, where there is no lecture on dates corresponding to cells with greyed out text or no text. See the official schedule on TimeEdit for information about the rooms.

Lecture slides

We will try, to the extent possible, to make the slides/lecture notes available online on this page the day before each class. However, this is not guaranteed to always happen, and in any case a new version of the slides may be uploaded after class according to what has actually been presented. Therefore, we encourage you to take notes independent of the slides material available before class.

Class # Date Topic Slides Comments
15 16 October 2017 Models and languages of concurrent computation slides
14 13 October 2017 Verification of concurrent programs slides
13 9 October 2017 Software transactional memory slides
example source code
12 2 October 2017 Parallel linked lists slides
examples source code
References: Herlihy & Shavit 9.
11 29 September 2017 Parallelizing computations slides
examples source code
References: Herlihy & Shavit 16.1, 16.4.
10 25 September 2017 Examples of message passing programs message passing tutorial
promela examples
Notes: We present examples of programming with message passing. Chap 8 of Ben-Ari does not provide many examples of parallelism, or programs with dynamic structures, so our examples may be useful. As in our tutorial before the first lecture, the examples are in Promela so you can experiment with the code on SPIN. Please take notes in class, as the programs are documented very tersely. In class, we will also talk about which of these programs (which use channels) can be coded in Erlang (no channels), and how.
9 22 September 2017 Reasoning about Monitors and Protected Objects slides (linda)
slides (monitors & protected objects)
Notes: Material from Chap 7 of Ben-Ari. If time permits, we will take a first look at Chap 9, on spaces.
8 18 September 2017 The material in Chap 3 of Ben-Ari proofs tutorial Notes: We will study “hardware processes” (which do busy-waiting instead of blocking), and study several attempts to solve the Critical Section (CS) problem without special atomic hardware instructions. We do proofs using both state diagrams and the program text.

Claims about state diagrams can be confirmed or debugged by a model checker, but these tools cannot say why a claim holds. That insight helps when modifying the program, and is given by proofs about a program from its text. A mechanical checker for such proofs would help, but, oddly, there are not very many proof checkers for concurrent programs. A first version of one was developed for a bachelor’s thesis by students from this course last year: Mechanical checkers are not exam material in this course, but look at this thesis for background.
7 15 September 2017 Erlang tutorial notes This will be a hands-on session going through the Erlang language, including everything you need to get started with the CCHAT lab. It is recommended that you look through the notes before the tutorial.
6 11 September 2017 More on FP concepts and message passing Notes: Today we will look at the concurrency chapters of the Erlang resources concentrating on the conceptual aspects. Hopefully this will give you a bird’s eye view before Friday’s tutorial.
If time permits, we will also do some examples in Ben-Ari’s textbook notation (the slides we use will be put up later).
5 8 September 2017 Introduction to Message Passing slides Notes: We postpone further study of examples and proofs of shared memory programs, whether hardware, semaphores, monitors or protected objects. I.e., chaps 3 – 7. We start message passing today to prepare you for Lab 2. This topic is in Chap 8 of Ben-Ari, but in coming lectures, we will try to do more examples than he gives.
4 6 September 2017 Monitors and protected objects slides Notes: We spent time figuring out invariant based proofs for bubble sort, for a linear program to extract the largest element in an array, and for the grid game with one player trying to make a closed circuit, and the other trying to prevent this.
We then looked at the design motivations for monitors and protected objects.
We also studied closely the state transition diagram for critical section with semaphores. What states are present/absent, and what invariant properties we can see in it.
3 4 September 2017 Invariants and Semaphores slides Notes:
  • This pretty much completes Chap 6 of Ben-Ari. We do an intro to invariants, and several semaphore examples. We also touch on invariant proofs for sequential programs and for programs with other concurrencymodels.
  • You can now read with profit the slides of Carlo’s first two lectures from SP3 2016/2017, (links: lecture 1, lecture 2).
  • The classic references from today:
    • Floyd’s “meanings” paper: link. One of the earliest papers on semantics.
    • Hoare’s “axiomatic” paper: link.
    • Dijkstr’a “semaphores”paper: link.
    • Dijkstrra’s “goto” letter: link.
    • An early paper on operational semantics (with reference to FP! https://en.wikipedia.org/wiki/SECD_machine): link.
  • Three of those authors won the Turing award not long after these papers https://en.wikipedia.org/wiki/Turing_Award (1972, 78, 80).
Assignment: Find invariants for bubblesort, maximum of a set, and for the grid game.
2 1 September 2017 Introduction to programming with semaphores slides Notes: Mostly chap 6 of Ben-Ari, but without treatment of invariants. We also use the test-and-set instruction from Chap 3, and the definition of critical section problem there.

Java Concurrency Examples: You can download the Java examples described in the second part of the lecture here.
1 28 August 2017 Introduction to principles of concurrent programming slides Notes: The first goal is to read Chap 6 of Ben-Ari, using only the minimum needed from the earlier chapters. We should reach this by the next lecture. The first idea is to find the software equivalent of an atomic action, with sleep state instead of busy wait, so it works for abstract processes instead of CPUs.

Assignment: Make enough progress with an Erlang tutorial to see if you can manage sequential programming. That will tell you whether you can manage the FP needed.

Lecture material from previous editions

If you want to get an idea of the material covered in the course before, here are the lecture notes used in previous editions of the course: