Reading material

The main study material consists of the slides that can be downloaded from Canvas. The code shown in the slides can also be downloaded in a ZIP file on Canvas. Below are further pointers to relevant documentation and academic literature that you are encouraged to read.

Tip

Most papers you can find for free online. If not, often if you connect to the internet using the network of the VUB you can get free access. You can also borrow copies of some of the books (contact me).

Lecture 1: Introduction

Recommended reading for some historical context:

• Herb Sutter (2005), The Free Lunch Is Over: A Fundamental Turn Toward Concurrency in Software, Dr. Dobb’s Journal, 30(3)
• Herb Sutter, James Larus (2005), Software and the Concurrency Revolution, ACM Queue, 3(7)
• Bryan Cantrill, Jeff Bonwick (2008), Real-World Concurrency, Communications of the ACM, 51(11)

Lectures 2 & 3: Erlang

Documentation for Erlang:

• The Erlang website, especially the documentation
• Erldocs.com: easy-to-search Erlang documentation

Books on Erlang:

• Fred Hebert (2013), Learn You Some Erlang for Great Good (freely available online).
• Armstrong (2007), Programming Erlang (not free, but available in SOFT library).
• Joe Armstrong et al (1996), Concurrent Programming in ERLANG.
• Stenman, The Erlang Runtime System, also called “the BEAM Book”, with lots of details about BEAM’s internal implementation (free online).

Erlang in the real world:

• Discord Blog (2017), How Discord Scaled Elixir to 5,000,000 Concurrent Users. Discord is a popular chat application written in Elixir. Elixir is a language built upon BEAM (Erlang’s Virtual Machine) and provides the same actor model as Erlang.
• High Scalability blog (2014), The WhatsApp Architecture Facebook Bought for $19 Billion. Scroll down the page to get some stats and information on WhatsApp’s usage of Erlang. At the bottom of the page you can also find links to other articles. WhatsApp used to be written in Erlang, but after it was bought by Facebook was rewritten to C++, because they couldn’t find enough qualified Erlang programmers.

Lecture 4: Benchmarking

Papers on how to collect and measure experimental results correctly:

• Georges, Buytaert, and Eeckhout (2007), Statistically Rigorous Java Performance Evaluation, OOPSLA’07
• Kalibera and Jones (2013), Rigorous Benchmarking in Reasonable Time, ISMM’13
• Fleming and Wallace (1986), How Not to Lie With Statistics: The Correct Way to Summarize Benchmark Results, CACM 29(3)

Lecture 5 – 7: GPU Programming with OpenCL

Recommended reading:

• “Hands On OpenCL” course that includes the materials used for lectures and lab exercises.
• Official OpenCL website from Khronos.

Lectures 8 & 9: Introduction to Clojure, Concurrency in Clojure

Clojure documentation:

• The Clojure website, in particular: the rationale; the articles on state and identity and concurrent programming; the official documentation.
• ClojureDocs: documentation and examples.

Recommended reading:

• Concurrency and Parallelism in Clojure.
• Daniel Higginbotham (2016), Clojure for the Brave and True: free book on Clojure, chapter 9 and 10 in particular.

Additional reading:

• Alex Miller et al (2018), Programming Clojure: a good book on Clojure (not free, but contact me for a copy).
• Clojure wikibook, in particular the learning by example section.

Lectures 10 & 11: Software Transactional Memory

Recommended reading:

• Clojure’s rationale behind refs and transactions
• Source code from the lectures on GitHub
• Simon Peyton Jones (2007), Beautiful Concurrency: the motivation for Software Transactional memory in Haskell. Highly recommended to ‘get’ the idea behind STM.

Additional reading:

• Harris, Marlow, Peyton Jones, Herlihy (2005), Composable Memory Transactions, PPoPP’05: paper on STM in Haskell.
• Herlihy and Shavit (2012), The Art of Multiprocessor Programming: Chapter 18 on Software Transactional Memory.

Lecture 12: Message passing vs. shared memory + Channel-based Concurrency

Recommended reading:

• C. A. R. Hoare (1978), Communicating Sequential Processes, Communications of the ACM, 21(8)
• The Clojure core.async library.
• Daniel Higginbotham (2016), Clojure for the Brave and True: chapter 11 on core.async.

Additional reading:

• Rich Hickey’s rationale behind the design of the Clojure core.async library.
• Concurrency in the Go programming language. Go’s concurrency model is based on CSP, with first-class channels but with weaker guarantees (i.e. processes, called goroutines in Go, are not fully isolated).
• Gul Agha (1990), Concurrent Object-oriented Programming, Communications of the ACM, 33(9)
• Occam-pi: one of the first practical programming languages building upon the CSP concurrency model and the pi calculus.

Lecture 13 alternative 1: OpenMP and MPI (time permitting)

Recommended reading:

• Course on OpenMP and MPI that goes into more depth.
• OpenMP consortium webpage
• Message Passing Interface Forum

Lecture 13 alternative 2: MapReduce (time permitting)

Recommended reading:

• Dean, Ghemawat (2004), MapReduce: Simplified Data Processing on Large Clusters, OSDI’04: the original paper on MapRecude.

Additional reading:

• Course series on MapReduce at MIT by Google Engineers, in particular the lecture Intro to MapReduce by Michael Kleber, Google.
• Chapter 20 of Programming Erlang discusses a very simplistic MapReduce in Erlang.
• Short MapReduce tutorial and larger course.