PDS – Parallel and Distributed Systems track

Master of computer science


  • CSC4508: Operating systems (François Trahay and Gaël Thomas, 5 ECTS)

    Web page: http://www-inf.telecom-sudparis.eu/COURS/CSC4508/Supports/index_ipparis.php

    This course presents the design principles of modern operating systems. In this course you will learn:

    • how applications interact with the operating system and how the operating system interacts with the hardware
    • the main internal mechanisms of an operating system (memory manager, I/O subsystem, scheduler)
    • how these mechanisms are implemented in a real operating system through the study of the XV6 operating system
    • how to develop parallel applications and parallel operating systems with threads

  • CSC5001: High performance runtimes (Élisabeth Brunet, François Trahay and Gaël Thomas, 5 ECTS)

    Web page: http://www-inf.telecom-sudparis.eu/COURS/CSC5001/new_site/Supports/
    Calendar: https://www-inf.telecom-sudparis.eu/COURS/masteripparis/pds/?page=../common/courses&genics=CSC5001

    With the advent of multicore processors (and now many-core processors with several dozens of execution units), expressing parallelism is mandatory to enable high performance on different kinds of applications (scientific computing, big-data...). In this context, this course details multiple parallel programming paradigms to help exploiting such a large number of cores on different target architectures (regular CPUs and GPUs). The course introduces distributed-memory model (MPI), shared-memory model (OpenMP) and heterogeneous model (CUDA). All these approaches would allow leveraging the performance of differents computers (from small servers to large supercomputers listed in Top500).

  • CSC5002: Middleware and software architecture for distributed applications (Sophie Chabridon, Chantal Taconet and Denis Conan, 5 ECTS)

    Web page: http://www-inf.telecom-sudparis.eu/COURS/CSC5002/
    Calendar: https://www-inf.telecom-sudparis.eu/COURS/masteripparis/pds/?page=../common/courses&genics=CSC5002

    This course presents how modern distributed applications are implemented. After this course, a student should be able to:

    • Identify and use the main interaction patterns between distributed components (synchronous call, callbacks, orchestration, asynchronous calls, publish/subscribe) through the study and practise of several middleware (RestFul Services, Web Services, Rabbit-MQ, JavaEE).
    • Design and implement a distributed application made of several functional modules with computing components, persistent components, client components. The application will be realised in the context of a microproject lasting during all the teaching unit.
    • Identify design patterns and architectural patterns used by middleware for distributed applications. Define the quality of a distributed architecture and discuss architecture choices to respond to quality of software architecture requirements (e.g. interoperability, security, scalability).

  • CSC5003: Data analytic infrastructures (Amel Bouzeghoub, 5 ECTS)

    Calendar: https://www-inf.telecom-sudparis.eu/COURS/masteripparis/pds/?page=../common/courses&genics=CSC5003

    This course presents data analytics infrastructures with a strong focus on Spark and on Web semantic.

  • CSC5004: Cloud infrastructures (Pierre Sutra and Mathieu Bacou, 5 ECTS)

    Web page: https://github.com/otrack/cloud-computing-infrastructures
    Calendar: https://www-inf.telecom-sudparis.eu/COURS/masteripparis/pds/?page=../common/courses&genics=CSC5004

    This course presents cloud infrastructures in order to:

    • acquire an overview of Cloud computing (e.g., data centers, everything-as-a-service, on-demand computing, cloud economy model)
    • apprehend the fundamental notions in Cloud computing (e.g., fault-tolerance, elasticity, scalability, load balancing)
    • understand how virtualization works (VM, container)
    • deconstruct and classify a distributed data store
    • recognize data consistency problems and know common solutions

    In details, a student will learn how to:

    • deploy and maintain IaaS
    • construct base data storage services (e.g., key-value store, coordination kernels)
    • construct and deploy a micro-service architecture
    • think for dependability & scalability

  • CSC5101: Advanced programming of multi-core architectures (Gaël Thomas, 5 ECTS)

    Web page: http://www-inf.telecom-sudparis.eu/COURS/chps/paam/
    Calendar: https://www-inf.telecom-sudparis.eu/COURS/masteripparis/pds/?page=../common/courses&genics=CSC5101

    This course presents advanced programming techniques for multi-core architectures: lock-free algorithms, transactional memory, virtualization techniques or techniques to mitigate non-uniform memory architectures. This module presents the theoretical concepts underlying these systems and their practical implementation.

  • IA307-master: Advanced GPU programming (Goran Frehse and Élisabeth Brunet, 2,5 ECTS)

    Web page: https://sites.google.com/site/frehseg/teaching/ia307
    Calendar: https://www-inf.telecom-sudparis.eu/COURS/masteripparis/pds/?page=../common/courses&genics=IA307-master

    The aim of this course is to give a vision of algorithms and their implementations in modern machine learning libraries on neural networks. In particular, the use of specific hardware, such as graphics cards, to improve performance is at the heart of these libraries. It is important to understand how the calculations are shared between the hardware and the CPU.

  • INF559: A Programmer’s Introduction to Computer Architectures and Operating Systems (Francesco Zappa Nardelli, Timothy Bourke and Théophile Bastian, 5 ECTS)

    Calendar: https://www-inf.telecom-sudparis.eu/COURS/masteripparis/pds/?page=../common/courses&genics=INF559

    We will explain the enduring concepts underlying all computer systems, and show the concrete ways that these ideas affect the correctness, performance, and utility of any application program.

    This course serves as an introduction to the students who go on to implement systems hardware and software. But this course also pushes students towards becoming the rare programmers who know how things work and how to fix them when they break.

    This course will cover most of the key interfaces between user programs and the bare hardware, including:

    • The representation and manipulation of information
    • Machine-level representation of programs
    • Processor architecture
    • The memory hierarchy
    • Exceptional Control Flow
    • Virtual memory

  • INF560: High performance runtimes (Patrick Carribault, 5 ECTS)

    Calendar: https://www-inf.telecom-sudparis.eu/COURS/masteripparis/pds/?page=../common/courses&genics=INF560

    With the advent of multicore processors (and now many-core processors with several dozens of execution units), expressing parallelism is mandatory to enable high performance on different kinds of applications (scientific computing, big-data...). In this context, this course details multiple parallel programming paradigms to help exploiting such a large number of cores on different target architectures (regular CPUs and GPUs).It includes distributed-memory model (MPI), shared-memory model (OpenMP) and heterogeneous model (CUDA). All these approaches would allow leveraging the performance of differents computers (from small servers to large supercomputers listed in Top500).

  • INF564: Compilation (Jean-Christophe Filliatre and Georges-Axel Jaloyan, 5 ECTS)

    Calendar: https://www-inf.telecom-sudparis.eu/COURS/masteripparis/pds/?page=../common/courses&genics=INF564

    This course is an introduction to compilation. It explains the techniques and tools used in the different phases of a compiler, up to the production of optimized assembler code. A compiler for a fragment of the C language to the x86-64 assembler is realized in TD.

  • INF571: Fundamentals in distributed computing 1 (Bernadette Charron-Bost, 5 ECTS)

    Calendar: https://www-inf.telecom-sudparis.eu/COURS/masteripparis/pds/?page=../common/courses&genics=INF571

    Distributed systems are composed of several computational units, classically called processes, that run concurrently and independently, without any central control. Additional difficulties are introduced by asynchrony (processes and channels operate at different speeds) and by limited local knowledge (each process has only a local view of the system and has a limited amount of information).

    Distributed algorithms are algorithms designed to run in this quite challenging setting. They arise in a wide range of applications, including telecommunications, internet, peer-to-peer computing, blockchain technology...

    This course aims at giving a comprehensive introduction to the field of distributed algorithms. A collection of significant algorithms will be presented for asynchronous networked systems, with a particular emphasis on their correctness proofs. Algorithms will be analyzed according to various measures of interest (eg., time and space complexities, communication costs). We will also present some "negative" results, i.e., impossibility theorems and lower bounds as they play a useful role for a system designer to determine what problems are solvable and at what cost.


    • Modelling of distributed networked systems
    • Wave and traversal algorithms
    • Leader election
    • Logical time and global snapshots
    • Detection of stable properties
    • Synchronizers
    • Link reversal algorithms

  • INF575: Safe Intelligent Systems (Sylvie Putot, 5 ECTS)

    Web page: https://moodle.polytechnique.fr/course/info.php?name=INF575-2020
    Calendar: https://www-inf.telecom-sudparis.eu/COURS/masteripparis/pds/?page=../common/courses&genics=INF575

    The interaction of computer components, which compute and communicate, with their environment governed by physical laws, such as an aircraft or an implanted medical system, is at the centre of the emerging field of cyber-physical systems. Among the challenges posed by these systems that we will focus on is the increasing use of artificial intelligence algorithms (typically neural networks) for both perception and control.

    Mastering the modelling, control and verification of the behaviour of such systems is crucial to guarantee the efficiency, functionality and reliability of these systems, which are increasingly complex and most often critical in terms of safety or cost.

    The course will focus on finding a balance between modeling and verification, and between theoretical foundations and practical aspects. In particular, it will introduce the principles and the use of some tools representative of the state of the art, and will focus on realistic case studies (notably a temporal model of a pacemaker modelled and verified with the Uppaal tool).


    • Introduction, models and synchronous languages
    • Synchronous Languages: Specification and Verification
    • Time-delayed automatons
    • Time logic and model-checking verification
    • Modeling and simulation of hybrid systems
    • Reachability analysis of hybrid systems
    • Stability and control of hybrid systems
    • Safety of intelligent stand-alone systems

    The course is illustrated by applicative exercises (in progress), and by practical work sessions using different modeling and verification tools. The last four sessions are dedicated to a project, in which the students can choose to focus on the modeling and verification of a cyber-physical system, or on the further study of an aspect of a verification method.

    The course will be validated for a small half on the practical work, and the remaining half on the project and associated oral.

  • INF583: Systems for big data (Angelos Anadiotis , 5 ECTS)

    Calendar: https://www-inf.telecom-sudparis.eu/COURS/masteripparis/pds/?page=../common/courses&genics=INF583

    This course covers the design principles and algorithmic foundation of influential software systems for Big Data Analytics. The course begins with the design of large enterprise data warehouses, Online-Analytic processing, and data mining over data warehouses. The course then examines fundamental architectural changes to scale data processing and analysis to a shared-nothing compute cluster, including parallel databases, MapReduce, column stores, and the support of batch processing, stream processing, iterative algorithms, machine learning, and interactive analytics in this new context.

  • INF636: Advanced topics in blockchains (Daniel Augot and Bernadette Charron-Bost, 5 ECTS)

    Calendar: https://www-inf.telecom-sudparis.eu/COURS/masteripparis/pds/?page=../common/courses&genics=INF636

    This course has two parts: Daniel Augot on the cryptography and blockchains, Bernadette Charron-Bost on the fundamentals of distributed algorithmics and of consensus.

    Daniel Augot's lectures present the cryptography used in blockchains. It will give an overview of several themes in the blockchain world, after quickly recalling the cryptography of basic (encryption, integrity, signature). The following topics will be examined: the many uses cryptographic hash functions; Ethereum, “smart contracts”; lightning, zero-knowledge, zk-snarks; secret-sharing.

    There will be many labs, which will consist in the manipulation of various software environments. We will use a lot of dockers the command line.

    Bernadette Charron-Bost's lectures will lay the fundamentals of problem of consensus (no practical work). In the problem of consensus, each agent in a networked system has some input value and must decide on some output value; it is necessary that all agents ultimately decide on the same value and that this common value is either one (or a function) of the input values. The problems of consensus arise in a number of applications including consistency in replicated databases, agents autonomous or, more recently, in blockchain technology.

    The problem of (exact) consensus is a fundamental agreement problem where each agent is aware that an agreement has been reached, by opposition to the stabilizing consensus problem where agents are just required to stabilize eventually on the same value entry. The blockchain consensus, also called the consensus of Nakamoto, corresponds to an intermediate type of agreement.

    The purpose of this course is to explore the solvency and complexity of these different agreement problems in different contexts, depending on the synchronicity model, the failure model and other properties such as whether the system is open or closed systems "without permissions" or "with permissions".

  • MITRO207: Distributed Computing and Combinatorial Topology (Petr Kuznetsov, 2,5 ECTS)

    The principal goal of this course is to learn the techniques for analyzing distributed algorithms for real systems combining parallelism with unpredictable delays, such as multi-cores, wireless networks, distributed systems, and Internet protocols. The use of mathematical tools of combinatorial topology has recently been used to close several long-standing open questions in fault-tolerant distributed computability. In this class, we learn how to master these tools. The course is based on the textbook by Maurice Herlihy, Dmitry Kozlov, and Sergio Rajsbaum, "Distributed Computing through Combinatorial Topology".

  • NET7212: Safe System Programming (Stefano Zacchiroli and Samuel Tardieu, 5 ECTS)

    Calendar: https://www-inf.telecom-sudparis.eu/COURS/masteripparis/pds/?page=../common/courses&genics=NET7212


    In this cours you will learn how to build system-level applications that avoid by construction memory safety issues and data race issues, by relying on modern type systems. You will be introduced to Rust as an example of a programming language that realizes this approach and has significant industry adoption.


    • Memory safety
    • How to detect memory-safety issues in C/C++
    • The Rust memory model
    • NULL references and how to avoid "billion dollar mistakes"
    • Rust language basics
    • Race conditions
    • Avoiding multiprocessing (security) pitfalls
    • Data races
    • Avoiding multithreading (security) pitfalls


    • Site: https://net7212.telecom-paris.fr/
    • Field: System programming and Software security
    • Keywords: programming, security, statictyping, memorysafety, multiprocessing, multithreading, rust
    • Evaluation: exam + project
    • Prerequisites:
      • operating systems foundamentals
      • C programming (C++ would be a plus)
      • POSIX programming
      • some experience with multithreading/multiprocessing programming

  • SLR201: Basics of distributed systems development (in Java) and software project management (Ada Diaconescu, 2,5 ECTS)

    Calendar: https://www-inf.telecom-sudparis.eu/COURS/masteripparis/pds/?page=../common/courses&genics=SLR201

    This course aims to introduce the basic notions necessary for the understanding and development of distributed applications (focused on Java). It also aims to introduce the concept of middleware and to provide two concrete examples of different middleware types: based on remote method invocations and message-oriented communication models.

  • SLR202: Object-oriented modelling: structural model and behaviour simulation (Ada Diaconescu, 2,5 ECTS)

    Calendar: https://www-inf.telecom-sudparis.eu/COURS/masteripparis/pds/?page=../common/courses&genics=SLR202

    The objective of this course is to learn the basics of the most popular standard in industry to model software architectures: UML. In the scope of a simple and generic design process, this course covers (i) the modelling of the functional requirements of a software application, ii) the design of software architectures with object oriented paradigms, and (iii) the behavioural modelling of software applications.

    This course will address the following topics:

    • Requirements specifications, expressed with use case diagrams
    • Object oriented architecture modelling, based on class diagrams refined with well-known design patterns from the Gang Of Four (GOF)
    • Interactions modelling with sequence diagrams
    • Behavioural models using state-chart diagrams

    This course also proposes a modelling approach, linking together these different UML2 diagrams, and following the recommendations that were standardised as a consensus in industry. Students will have to apply this modelling approach on a project using tools.

  • SLR203: Introduction to technologies of distributed software development (Ada Diaconescu and Rémi Sharrock, 2,5 ECTS)

    This course introduces the basic concepts of tools for distributed systems and middleware and presents concrete examples of middleware of different styles: RMI , MOM/JMS and Akka. These examples will be compared in order to better understand their applicability to different types of applications. The concepts explored here, via fairly simple examples, are reused in most middleware and application server platforms available in the industry.

  • SLR204: Basics of verification of distributed systems (Vadim Malvone , 2,5 ECTS)

    Calendar: https://www-inf.telecom-sudparis.eu/COURS/masteripparis/pds/?page=../common/courses&genics=SLR204

    The aim of this module is to introduce key concepts related to the formal verification of concurrent and distributed software. This module presents the basis of 3 approaches for verification: Process Algebras, Temporal Logic and Petri Nets. The following aspects are addressed:

    • Introduction and role of verification in the development process, behavioral modeling, property modeling, formal semantics.
    • Verification through state exploration, proof based verification.
    • Remarkable properties: non-determinism, deadlock, livelock, fairness, starvation, etc.
    • Process algebras approach for behavioral modeling. Labelled Transition Systems.
    • Equivalences between behaviors: trace equivalent, test equivalent, bisimilar behaviors.
    • Temporal logics (LTL et CTL) for expressing verifiable properties. Kripke structure for modeling behaviors. Model Checking verification.\ Buchi Automata, Fix point.
    • Petri Nets, modeling of concurrency, synchronization, conflict.
    • Verification of behavioral properties, invariants.

  • SLR206: Fundamentals in distributed computing 2 (Petr Kuznetsov, 5 ECTS)

    Calendar: https://www-inf.telecom-sudparis.eu/COURS/masteripparis/pds/?page=../common/courses&genics=SLR206

    The primary focus of the module is on understanding the foundations of distributed computing. The module will discuss basics of synchronization, fault-tolerant shared-memory computations, consensus and transactional memory.

  • SLR207: Technologies of large-scale parallel computing (Rémi Sharrock, 2,5 ECTS)

    Calendar: https://www-inf.telecom-sudparis.eu/COURS/masteripparis/pds/?page=../common/courses&genics=SLR207

    This Learning Module presents distributed computing and large scale technologies. An illustration will be given by implementing a real large scale distributed system.

    • Knowing large scale concepts, parallelization, virtualization, elasticity, overlay networks, autonomic computing and their applications for cloud computing,
    • Manipulating cloud services with a particular provider (for example Amazon),
    • Understanding MapReduce concepts,
    • Implementing MapReduce with a local simulation and an Amazon cloud deployment.


    • SLR201
    • Be capable of implementing distributed applications in Java.

  • SLR210: Algorithmic basics of distributed storage systems and blockchains (Petr Kuznetsov and Matthieu Rambaud, 2,5 ECTS)

    Calendar: https://www-inf.telecom-sudparis.eu/COURS/masteripparis/pds/?page=../common/courses&genics=SLR210

    Understanding of the algorithmic foundations behind the blockchain technology: we study the algorithmic basics behind decentralized and consistent storage systems that tolerate churn and malicious behavior of participating nodes. We begin with the study of classical protocols for reconfigurable storage and Byzantine fault-tolerance. Then we explore the protocols designed for "open" systems, exemplified by the prominent blockchain technology.

  • SLR304: Dynamic, autonomic and self-adapting systems (Ada Diaconescu, 2,5 ECTS)

    This course presents both algorithms and techniques used to implement self-adapting systems.

  • SLR305: Algorithms for dynamic and reconfigurable distributed systems (Petr Kuznetsov, 2,5 ECTS)

    This course presents algorithms commonly used to implement dynamic and reconfigurable distributed systems.

  • FLE2: French courses for foreign students (M1/S2) (Nicoline Lagel, 2,5 ECTS)
  • Free ECTS: Free ECTS (7,5 ECTS)

    A student can choose 7.5 ECTS from any track (his/her main track included) of the master degree in computer science.

  • Internship: 6-month M2 research internship (30 ECTS)
  • M1 PDS Project: M1 PDS research projects (30 ECTS)

    Web page: ?page=../common/research-projects-2023-2024

    During the master, a student will learn research by doing research. During the two years of the master, a student will thus spend between one or two days each week in a research group in order to do research projects with professors and PhD students of IP Paris.

  • M1 Seminar: M1 Seminar (5 ECTS)

    Web page: https://www.inf.telecom-sudparis.eu/pds/seminars/
    Calendar: https://www-inf.telecom-sudparis.eu/COURS/masteripparis/pds/?page=../common/courses&genics=M1 Seminar

    The seminar consists in presentations of ongoing research works, both by students on papers of conferences or journals, and by professors from IP Paris and other universities.

  • M2 PDS Project: M2 PDS research projects (12,5 ECTS)

    Web page: ?page=../common/research-projects-2023-2024

    During the master, a student will learn research by doing research. During the two years of the master, a student will thus spend between one or two days each week in a research group in order to do research projects with professors and PhD students of IP Paris.

  • M2 Seminar: M2 Seminar (2,5 ECTS)

    Web page: https://www.inf.telecom-sudparis.eu/pds/seminars/
    Calendar: https://www-inf.telecom-sudparis.eu/COURS/masteripparis/pds/?page=../common/courses&genics=M2 Seminar

    The seminar consists in presentations of ongoing research works, both by students on papers of conferences or journals, and by professors from IP Paris and other universities.