Runtimes for concurrency and distribution
Master Degree in Computer Science
University of Padova, a.y. 2021/2022
Instructor: Tullio Vardanega

(Latest update: 12 January 2022, 12:20)
[added on-request closing seminar]

Outline of course

Learning outcomes

The higher the level of abstraction (and thus the expressive power) of the programming language - which actually means the more distant from the actual operation of the underlying processor hardware -, the larger the role played by the software layer that implements the fraction of semantics of it that cannot be fully resolved at compile time. That software layer is usually termed language runtime.

Most evidently, such language features as concurrency and distribution involve semantics that is not primitive to the computer hardware, and therefore require the compilation system of the corresponding programming language to be augmented with software libraries dedicated to make the relevant semantics happen at run time.

This class aims at exploring the requirements placed on such runtimes, and their typical operation, considering exemplary paradigms of language-level concurrency and distribution, progressively ranging from single-CPU computers to the Cloud.

The instructional method used in this class will combine frontal lectures with multimedia resources, homework assignments, and flipped-class activities.

Useful reading

Concurrent and Real-Time Programming in Ada
Alan Burns and Andy Wellings
Cambridge University Press ISBN 978-0-521-86697-2
Distributed Systems - Principles and paradigms (2nd edition)
Andrew S Tanenbaum, Maarten van Steen
Pearson Prentice Hall ISBN 0-13-239227-5

Technology resources

Lecture schedule

Week	Date	Lecture #	Lecture Topic
1	27 September	1	On the notion of run-time support
1	29 September	2	On multi-programming
2	04 October	3	On virtualization Resources: What is an Application Binary Interface Homework: Investigate the inner (under the hood) workings of Virtualbox
2	06 October	4	On concurrent programming Homework: Scrutinize the "driving motivation" of modern languages that have chosen to support co-routines or other forms of concurrency Resources: C#'s concurrency model Resources: Per Brinch Hansen on Java concurrency Resources: The inheritance anomaly problem
3	11 October	5	Continuation of lecture 4
3	13 October	6	On communication among threads
4	18 October	7	Continuation of lecture 6 Resources: About Ada tasking Resources: Ada for the C++ or Java developer Example: The notion of master & dependent
4	20 October	8	On synchronous message passing Example: Programmatic realization of the Dining Philosophers case
5	25 October	9	Continuation of lecture 8 In-class exercise: analysis of Eratosthenes' sieve: synchronous version Homework: try and reproduce the above program in your language of election
5	27 October	10	On monitor-like asynchronous communication Example: Application-level control of call queuing Example: A producer-consumer system with bounded buffer Homework: Study Eratosthenes' sieve: asynchronous version and reproduce in your language of election Resources: Per Brinch Hansen: "Structured Multiprogramming" (CACM, 1972)
6	03 November	11	Continuation of lecture 10
7	08 November	FC1	(*Flipped class*) You report on other models of language-level concurrency and we all discuss your findings
7	10 November	12	On the multiple facets of synchronization Example: Application-level allocation of resources Resources: Toby Bloom: "Evaluating Synchronization Mechanisms" (CACM, 1979)
8	15 November	FC2	(*Flipped class*) You constructively solve a design-and-programming problem posed by the instructor
8	17 November	FC3	Continuation of FC2 Example: An elegant solution in Ada Homework: Try and reproduce (or improve) the example solution in your language of election and single out the comparative pros and cons
9	22 November	13	An introduction to distributed systems Resources: On system scalability
9	24 November	14	Continuation of lecture 13
10	29 November	15	Distributed inter-process communication Resources: Naming & DNS
10	01 December	16	Continuation of lecture 15
11	06 December	17	Distributed concurrency Resources: Statelessness
12	13 December	18	Distributed synchronization Resources: Chandy and Lamport's "distributed snapshot" Homework: Study the inner workings of this demonstrative concurrent Ada implementation of Chandy-Lamport's distributed snapshot Resources: Lecture material @ Cornell University (Ken Birman)
12	15 December	19	Continuation of lecture 18
13	20 December	20	The native distribution model in (early) Java Resources: Java RMI programming according to Oracle
			Exam themes' specification and requirements
14	10 January 2022	21	The native distribution model in Ada Example: Distributed version of Eratosthenes' sieve in Ada - source code Resources: Another use-case example Resources (inside the runtime): GLADE, RT-GLADE Resources (a message-oriented Middleware): YAMI4
	12 January 2022	22	Cloud computing: an introduction Further reading #1 (for self-study) Ken Birman @ Cornell view of the Cloud Further reading #2 (for self-study, past exam outputs, in Italian) Cloud-enabled applications Scalability and multitenancy
	14 January 2022 (16:00-17:00 Zoom only)	23	Closing seminar: Cloud computing: orchestration as the new middleware

Hall assignment and Zoom links

The hall assignment for the lectures in the schedule are reported in the relevant UNIPD's app.

The corresponding Zoom links will be communicated via the Moodle page of this class.

Appointments with students

Students are welcome to request personal or group appointments with the instructor, who will offer either a face-to-face or a Zoom-based meeting as the circumstances will allow.