Courses
- 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://cs.ip-paris.fr/courses/tracks/pds/?page=../common/courses&genics=CSC5001With 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://cs.ip-paris.fr/courses/tracks/pds/?page=../common/courses&genics=CSC5002This 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://cs.ip-paris.fr/courses/tracks/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://cs.ip-paris.fr/courses/tracks/pds/?page=../common/courses&genics=CSC5004This 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://cs.ip-paris.fr/courses/tracks/pds/?page=../common/courses&genics=CSC5101This 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
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.
- CSC_51057_EP (INF557): From the Internet to the IoT: Fundamental of Modern Computer Networking (Thomas Clausen, 5 ECTS)
Calendar: https://cs.ip-paris.fr/courses/tracks/pds/?page=../common/courses&genics=CSC_51057_EP
The 21th century is, if anything, becoming a data-driven century. Interaction with everyday objects may yield a wealth of information, especially when correlated: if in an apartment the fridge door is being opened and closed regularly, then presumably apartment is inhabited ; if a drinking glass is subsequently emptied, presumably the inhabitant is alive and well, and, is staying both fresh and hydrated ; if the BBQ or the oven is used frequently, perhaps the inhabitant is either overeating (and so, a potential customer for diet plans) or is entertaining frequently (and so, a a potential customer for party supplies) — something which analysing the usage patterns of the door bell would reveal…
A premise for being able to analyse usage patterns and interactions is, of course, that these physical actions are captured and transformed into data — and, that these data are communicated from everyday objects with and through the Internet, and to the cloud.
And so, the 21th century is necessarily also the connected century: smartphones, watches, fridges, toothbrushes, drinking glasses, coffee machines, medical implants, BBQs, office plants, and forks are all becoming connected objects, generating data — and thus, becoming part of the Internet.
Outside of the consumer market, knowing the state of a machine, of an airplane engine, or of a power substation, permits scheduling predictive maintenance and avoid accidents — embedded sensors able to capture, and communicate, this state is a necessary premise.
As a matter of fact, a company launching a product today that doesn't "run an app" and "connects to the Internet" is a company, which just hasn't grasped the needs (or, at least, the desires) of its market - much as the guy installing the bike rack on the left, clearly misunderstood his "target market".
In order to ensure that YOU do not end up being that gal/guy, building a product miserably missing the market, this course provides you with the core competencies, necessary for developing connected systems.
This course:
- Offers a pragmatic and practical approach to communicating systems and to computer networking
- Studies, for each of the four major functional layers in a protocol stack (data-link, internetwork, transport, and application) the fundamental ideas, algorithms, and architectural principles, that apply “from the Internet, and to the IoT”
- Provides an in-depth tutorial in the principles behind TCP/IP Networking
- Introduces and decrypts modern Internet and IoT protocols: from IPv6 to 6LoWPAN, from ALOHA through Ethernet and WiFi to LoRa and Bluetooth — and from the WEB and REST to CORE And CoAP
- Provides practical experience in developing networked applications, and in developing and implementing protocols.
In short, this course provides an in-depth understanding of “how the net works” (pun intended), and gives the necessary baggage for an engineer (regardless of area of exercise) to be able to design communicating systems.
This course is self-contained: it assumes some programming skills, and a lot of curiosity — and will introduce the rest as it goes along. Each lesson will consist of a lecture, followed by 2h of lab (TD). This course is calibrated so that a student should expect to spend 1-2h/week outside of class, reviewing material and/or finishing exercises.
Requirements:
A good dose of curiosity is required.
(Having followed INF321 or INF311+411 probably won’t hurt)Evaluation mechanism:
Weekly submissions (either of homework, or of quizzes) worth 50% of the final grade, and a final exam QCM worth the other 50% of the grade.
Language:
English (with, at least, bilingual teaching staff)
The 21th century is, if anything, becoming a data-driven century. Interaction with everyday objects may yield a wealth of information, especially when correlated: if in an apartment the fridge door is being opened and closed regularly, then presumably apartment is inhabited ; if a drinking glass is subsequently emptied, presumably the inhabitant is alive and well, and, is staying both fresh and hydrated ; if the BBQ or the oven is used frequently, perhaps the inhabitant is either overeating (and so, a potential customer for diet plans) or is entertaining frequently (and so, a a potential customer for party supplies) — something which analysing the usage patterns of the door bell would reveal…
A premise for being able to analyse usage patterns and interactions is, of course, that these physical actions are captured and transformed into data — and, that these data are communicated from everyday objects with and through the Internet, and to the cloud.
And so, the 21th century is necessarily also the connected century: smartphones, watches, fridges, toothbrushes, drinking glasses, coffee machines, medical implants, BBQs, office plants, and forks are all becoming connected objects, generating data — and thus, becoming part of the Internet.
Outside of the consumer market, knowing the state of a machine, of an airplane engine, or of a power substation, permits scheduling predictive maintenance and avoid accidents — embedded sensors able to capture, and communicate, this state is a necessary premise.
As a matter of fact, a company launching a product today that doesn't "run an app" and "connects to the Internet" is a company, which just hasn't grasped the needs (or, at least, the desires) of its market - much as the guy installing the bike rack on the left, clearly misunderstood his "target market".
In order to ensure that YOU do not end up being that gal/guy, building a product miserably missing the market, this course provides you with the core competencies, necessary for developing connected systems.
This course:
- Offers a pragmatic and practical approach to communicating systems and to computer networking
- Studies, for each of the four major functional layers in a protocol stack (data-link, internetwork, transport, and application) the fundamental ideas, algorithms, and architectural principles, that apply “from the Internet, and to the IoT”
- Provides an in-depth tutorial in the principles behind TCP/IP Networking
- Introduces and decrypts modern Internet and IoT protocols: from IPv6 to 6LoWPAN, from ALOHA through Ethernet and WiFi to LoRa and Bluetooth — and from the WEB and REST to CORE And CoAP
- Provides practical experience in developing networked applications, and in developing and implementing protocols.
In short, this course provides an in-depth understanding of “how the net works” (pun intended), and gives the necessary baggage for an engineer (regardless of area of exercise) to be able to design communicating systems.
This course is self-contained: it assumes some programming skills, and a lot of curiosity — and will introduce the rest as it goes along. Each lesson will consist of a lecture, followed by 2h of lab (TD). This course is calibrated so that a student should expect to spend 1-2h/week outside of class, reviewing material and/or finishing exercises.
- CSC_51059_EP (INF559): A Programmer’s Introduction to Computer Architectures and Operating Systems (Francesco Zappa Nardelli, Timothy Bourke and Théophile Bastian, 5 ECTS)
Calendar: https://cs.ip-paris.fr/courses/tracks/pds/?page=../common/courses&genics=CSC_51059_EP
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
- CSC_52060_EP (INF560): High performance runtimes (Patrick Carribault, 5 ECTS)
Calendar: https://cs.ip-paris.fr/courses/tracks/pds/?page=../common/courses&genics=CSC_52060_EP
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).
- CSC_52064_EP (INF564): Compilation (Jean-Christophe Filliatre and Georges-Axel Jaloyan, 5 ECTS)
Calendar: https://cs.ip-paris.fr/courses/tracks/pds/?page=../common/courses&genics=CSC_52064_EP
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.
- CSC_51071_EP (INF571): Distributed Data Structures, with a Spotlight on Blockchains (Constantin Enea and Daniel Augot, 5 ECTS)
Calendar: https://cs.ip-paris.fr/courses/tracks/pds/?page=../common/courses&genics=CSC_51071_EP
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.
- CSC_51075_EP (INF575): Safe Intelligent Systems (Sylvie Putot, 5 ECTS)
Web page: https://moodle.polytechnique.fr/course/info.php?name=INF575-2020
Calendar: https://cs.ip-paris.fr/courses/tracks/pds/?page=../common/courses&genics=CSC_51075_EPThe 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).
Content:
- 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.
- CSC_52083_EP (INF583): Systems for big data (Angelos Anadiotis , 5 ECTS)
Calendar: https://cs.ip-paris.fr/courses/tracks/pds/?page=../common/courses&genics=CSC_52083_EP
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.
- CSC_4MI07_TP (MITRO207): Distributed computing through combinatorial topology (Petr Kuznetsov, 2,5 ECTS)
Calendar: https://cs.ip-paris.fr/courses/tracks/pds/?page=../common/courses&genics=CSC_4MI07_TP
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://cs.ip-paris.fr/courses/tracks/pds/?page=../common/courses&genics=NET7212
Description
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.
Syllabus
- 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
Meta
- Site: https://ssp-rs.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
- CSC_4SD01_TP (SD201): Data Mining (Mauro Sozio, 2,5 ECTS)
- CSC_5SE01_TP (SE301a): Embedded Critical Real-Time Systems (STREC) part 1 (Laurent Pautet, 2,5 ECTS)
Calendar: https://cs.ip-paris.fr/courses/tracks/pds/?page=../common/courses&genics=CSC_5SE01_TP
This course aims at giving to the students the knowledge required to design critical embedded real-time systems. In particular, the course focuses on issues related to the satisfaction of non-functional requirements (software constraints, hardware constraints, time constraints …). The different lectures concern algorithmic notions such as scheduling theory, analysis and generation of embedded code, approaches for dependability or industrial standards used in the avionic, automotive or railroad domains.
- CSC_5SE02_TP (SE301b): Embedded Critical Real-Time Systems (STREC) part 2 (Thomas Robert, 2,5 ECTS)
This course aims at giving to the students the knowledge required to design critical embedded real-time systems. In particular, the course focuses on issues related to the satisfaction of non-functional requirements (software constraints, hardware constraints, time constraints …). This lecture extends the content of se301a with content on worst case execution time analysis, source code synthesis from behavioral models, and how to define dependability goals and achieve them through fault tolerance.
- CSC_4SL01_TP (SLR201): Advanced Programming and Project Management (Java-based) (Ada Diaconescu, 2,5 ECTS)
Calendar: https://cs.ip-paris.fr/courses/tracks/pds/?page=../common/courses&genics=CSC_4SL01_TP
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.
- CSC_4SL02_TP (SLR202): Software System Modelling and Design (Ada Diaconescu, 2,5 ECTS)
Calendar: https://cs.ip-paris.fr/courses/tracks/pds/?page=../common/courses&genics=CSC_4SL02_TP
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.
- CSC_4SL03_TP (SLR203): Introduction to technologies of distributed software development (Ada Diaconescu and Rémi Sharrock, 2,5 ECTS)
Calendar: https://cs.ip-paris.fr/courses/tracks/pds/?page=../common/courses&genics=CSC_4SL03_TP
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.
- CSC_4SL04_TP (SLR204): Introduction to formal verification of Distributed Software and Systems (Vadim Malvone , 2,5 ECTS)
Calendar: https://cs.ip-paris.fr/courses/tracks/pds/?page=../common/courses&genics=CSC_4SL04_TP
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.
- CSC_4SL05_TP (SLR206a): Distributed algorithms (Part A) (Petr Kuznetsov, 2,5 ECTS)
Calendar: https://cs.ip-paris.fr/courses/tracks/pds/?page=../common/courses&genics=CSC_4SL05_TP
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.
- CSC_4SL06_TP (SLR206b): Distributed algorithms (Part B) (Petr Kuznetsov, 2,5 ECTS)
Calendar: https://cs.ip-paris.fr/courses/tracks/pds/?page=../common/courses&genics=CSC_4SL06_TP
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.
- CSC_4SL07_TP (SLR207): Technologies of large-scale parallel computing (Rémi Sharrock, 2,5 ECTS)
Calendar: https://cs.ip-paris.fr/courses/tracks/pds/?page=../common/courses&genics=CSC_4SL07_TP
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.
Prerequisites:
- SLR201
- Be capable of implementing distributed applications in Java.
- CSC_4SL08_TP (SLR210): Blockchain: algorithmic basics (Petr Kuznetsov and Matthieu Rambaud, 2,5 ECTS)
Calendar: https://cs.ip-paris.fr/courses/tracks/pds/?page=../common/courses&genics=CSC_4SL08_TP
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.
- FLE1: French courses for foreign students (M1/S1) (Nicoline Lagel, 2,5 ECTS)
- FLE2: French courses for foreign students (M1/S2) (Nicoline Lagel)
- FLE3: French courses for foreign students (M2/S1) (Nicoline Lagel)
- 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)
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 (2.5 ECTS)
Web page: https://www.inf.telecom-sudparis.eu/pds/seminars/
Calendar: https://cs.ip-paris.fr/courses/tracks/pds/?page=../common/courses&genics=M1 SeminarThe 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)
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://cs.ip-paris.fr/courses/tracks/pds/?page=../common/courses&genics=M2 SeminarThe 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.