Weekly outline


    • This on-line resource is the main landing page for this curriculum class, in addition to the corresponding Moodle base. Said resource recaps the class intent and presents the baseline schedule, regularly updated, of all lectures of this class. Students shall refer to that resource for the date, the topic, and the study material of the corresponding lecture.

    • All class lectures in the first semester (starting on 27-September) are meant to be in-person, in lecture hall LuF1, at full capacity, for students in possession of a valid EU green certificate, and wearing conforming face masks. Students who, for sound reasons, should be unable to attend in person, may use the above Zoom coordinates for joining lecture remotely. 

  • 27 September - 3 October

    The two lectures scheduled in week 1 do not use slide decks, intentionally, in the intent of pushing the students to recall (and better understand) basic concepts previously seen in bachelor education, in such classes as "Processor Architecture" and "Operating System". In particular, Lecture 1 recaps how a processor executes and explains what an executable binary is made of, while Lecture 2 discusses where did multi-programming originate from and what basic mechanisms it rests on.

    Students are recommended to consolidate their understanding of such topics by returning to the corresponding basics via the study materials they used in their bachelor studies.

  • 4 October - 10 October

    The two lectures of this week (#3, #4) do use slide decks, which are published in the "lecture schedule" page referred to earlier.

    Lecture 3 discusses virtualization, a major enabler to program execution as we know it, recalling its origin, and its various manner of realization, with present-day examples that the students should be able to recognize in their own use of processing resources.

    Lecture 4 discusses what concurrent programming is, how it can be realized within the language runtime, and concludes by showing how the notion of time inevitably emerges as a necessary resource for execution that may be pre-empted.

    Each lecture is accompanied by reading resources, which the students are invited to consume.

  • 11 October - 17 October

    Lecture 5, due on 11 October (which will take place via Zoom) will continue discussing the basics of concurrent programming, along with the associated reading resources.

    Lecture 6, scheduled on 13 October (which will return to in-person) will begin to illustrate the subject of communication among concurrent threads, which will extend into the subsequent lecture. The lecture material is available for download on the lecture schedule page already known by the students.

  • 18 October - 24 October

    Lecture 7, due on Monday, 18 October, follows on from where lecture 6 ended, continuing and completing a first, general overview of how threads may communicate with one another within a program.

    Lecture 8, due on Wednesday, 20 October, delves into a concrete realization of synchronous message passing (direct link to lecture material). This topic will continue with Lecture 9, on Monday, 25 October, where students will be requested to make an in-class exercise, which will require the students to study, debug, and run the code example posted here.

    Students are advised that, on Monday, 8 November, the activity in class will be flipped: students will be required to prepare and deliver a short (8-minute) live presentation highlighting the model of concurrency featured by a programming language of their own liking.

    In order to avoid redundancy, students shall notify explicitly the instructor of their presentation choice beforehand, by the time of Lecture 11, on Wednesday, 3 November.

  • 25 October - 31 October

    Lecture 9, due on Monday, 25 October, follows on from where lecture 8 ended, continuing the exploration of the ways in which synchronous communication between threads may occur. The core of the activity in class will be the autopsy of the example problem whose material is tagged "in-class exercise" in the lecture schedule

    Lecture 10, due on Wednesday, 27 October, begins to explore the virtues and challenges of a concrete implementation of a state-of-the-art version of the monitor we discussed in Lecture 7 (direct link to the lecture material). The lecture activity includes the specification of homework that the students are required to carry out before attending Lecture 11 (direct link here).

  • 1 November - 7 November

    We are running one step behind the official lecture schedule.

    This delay follows from us having devoted Lecture 10, on October 27, to the in-depth discussion of the in-class exercise attached to Lecture 9: that was time well spent, I hope, for you to understand the termination behaviour of servers.

    However, that delay is having a cascading effect on our progress, which you should be aware of, and make up for as much as possible. Let me break it out so that you may appreciate it fully:

    You shall still (note the imperative) do that homework before L12, due on Wednesday, November 10, so that we can devote the first 15 minutes of L12 to go over your findings prior to addressing the day's topic.
  • 8 November - 14 November

    Activity FC1, due on Monday, November 8, shall be flipped, as previously announced, focused on exploring the model of concurrency provided by a variety of other languages than Ada: notably, C#, Go, Haskell, Python, and Rust. We shall also look at JavaScript, which is single-threaded in the user space, but has a distinct model of concurrency "under the hood".

    The subsequent lecture, L12, due on Wednesday, November 10, will return to the subject of synchronization as a powerful means for the interaction among threads. That discussion will complete the review of concurrency, which will culminate, next week, in a flipped-classroom activity that will span two consecutive dates and will consist of a collaborative design-and-programming in-class exercise.

  • 15 November - 21 November

    As reported in the lecture schedule, the class activities due this week shall consist of a collective exercise of design and implementation of a concurrent program that meets the specification requirements listed on the last page of the material presented in Lecture 12.

  • 22 November - 28 November

    As noted, Lecture 13, due on Monday, 22 November, marks the beginning of the second half of the course program, with focus shifting from concurrency to distribution.

    At the start of L13, however, we shall devote some 15 minutes to check your progress with the realization of the example system discussed in FC2.

    Lecture 14, due on Wednesday, 24 November, shall continue ploughing through the same material as L13.

  • 29 November - 5 December

    In the two lectures of this week (#15 and #16) we shall discuss how inter-process communication works under distribution. The discussion will span the (relatively rapid) progress that took distributed programming from remote procedure calls (RPC) over TCP to all manners of cloud-enabled calls over evolutions of HTTP.

    Be advised that, owing to away-from-home obligations of the instructor's, both such lectures shall be delivered via Zoom, at the coordinates specified at the top of this Moodle page.

  • 6 December - 12 December

    This week will have a single lecture (#17), on Monday, December 6, which will explore the role of concurrency in the server- and client-side of distributed systems.

    The students shall use the spare time gained on Wednesday, December 8, to read this story and comment back in writing to the instructoron, on the lessons learned from it.

  • 13 December - 19 December

    This week we shall address the topic (#18) of how can distributed agents synchronize their work without resorting to shared memory and global clock. This subject matter is so important to this lecture series that its discussion will span two consecutive lectures.

    Once again, the lecture material includes a demo program, written in Ada, to illustrate a concrete application of a state-of-the-art algorithm for distributed synchronization. The students are invited to study that program for logic and execution, and to reproduce its functional behaviour in a programming language of their choice.

  • 20 December - 26 December

    This week will have a single lecture (#20), on Monday, December 20, which will illustrate a notable model of language-specific distributed programming (Java in this instance). As mentioned in earlier lectures, the traditional approach to language-based distribution based on TCP and reflected the client-service architecture intrinsic in that request-reply protocol.

    The course will resume on Monday, January 10, after the Christmas and New Year break. In that week, we shall see another instance of language-specific distributed programming (Ada), and close the lecture series with a view of Cloud computing.

    • At the close of the year, with only a few lectures left to the end of this course, it is high time for you to take notice of the exam themes and requirements that apply to your group. Make sure you read carefully the relevant material (and ask questions for any clarifications you may need) and understand the exam schedule specified on page 6/6 of said document.

  • 10 GENNAIO - 16 GENNAIO 2022

    In this final week of the course, we shall have two lectures:

    • on Monday, January 10, we shall look at the native distribution model in Ada, to complete the review of TCP-based homogeneous approaches to distributed programming.
    • on Wednesday, January 12, we shall discuss the essence of Cloud Computing, which represents the culmination of the progression we made in the interpretation of distributed programming in this course.
    On the side of these two lectures, the students shall report on their having taken notice of the exam requirements and being ready to declare their theme of choice and the expected delivery date.