24h, 2,5 ECTS, Ada Diaconescu
Objective
This course offers more advanced notions of Java programming, compared to what was seen in the 1st year courses (INF103). Mastering these notions is essential for comprehending the main concepts of distributed systems (SLR203). The course also provides more detailed notions of project management, including the management of software versions, of library interdependencies, and of agile development processes.
Syllabus
This course includes the following subjects:
- Java Threads, synchronisation, object serialisation, Input/Output interfaces and Sockets;
- version management via advanced git (e.g. branches, conflict management, SmartGit platform);
- automated software compilation, packaging and execution via the Apache Ant (or Maven) tool;
- introduction to the agile method (e.g. Scrum) for software project development.
Prerequisites
A good understanding of Object Oriented Programming (OOP) and basic experience with Java programming
24h, 2,5 ECTS, Ada Diaconescu, Vadim Malvone, Dominique Blouin
Objectives
This course offers an introduction to the software development process, focusing on software system modelling and design tools. The course mainly discusses object-oriented approaches, but may also include component- and service-oriented architectures. Notably, the course includes a set of design patterns, some of most commonly used (GoF), while emphasising their usage in the design of large-scale distributed systems. The UML standard notation, one of the most commonly employed in the industry, will be used to illustrate and apply the theoretical modelling concepts presented.
Syllabus
This course will address the following topics:
Requirements specification via scenarios and Use Case diagrams;
Object-Oriented architectural modelling via Class diagrams, refined by common design patterns (GoF);
Illustrative examples of the use of design patterns for developing large-scale distributed systems (e.g. application servers);
Interaction modelling viaSequence diagrams;
Behavioural modelling via state-chart diagrams.
Prerequisites
Good understanding of Object Oriented Programming (OOP)
24h, 2,5 ECTS, Ada Diaconescu
Objectives
This course introduces essential notions for comprehending distributed systems and their development based on middleware (using Java as an example). It offers several concrete middleware examples, including: based on a remote method invocation model; on a remote passing model; and on an "actor" model. A comparison amongst presented middleware examples will enable a better understanding of their applicability to different application domains.
Syllabus
This course includes the following topics:
Basic notions of distributed systems and middleware
RMI as a middleware example for remote method invocation;
JMS (and/or MQTT) as middleware example for remote message passing;
Akka as middleware example for actor models;
Comparison of presented middleware examples, highlighting their applicability to different domains
Prerequisites
SLR201
Good knowledge and experience with Object-Oriented programming (preferably Java)
24h, 2,5 ECTS, Vadim Malvone, Gérard Memmi
Objectives
The aim of this module is to introduce key concepts related to the formal verification of concurrent and distributed systems.
Syllabus
This module presents the basis of two approaches for verification: Model Checking and Petri Nets. The following aspects are addressed:
Introduction and role of verification in the development process.
Kripke structures for modeling systems.
Temporal logics (LTL and CTL) for expressing verifiable properties.
Model Checking verification: solving LTL model checking via Buchi Automata.
Model Checking verification: solving CTL model checking via Labeling procedure.
Petri Nets, modeling of concurrency, basic properties.
Verification of behavioral properties and invariants.
No prerequisites
48h (2x24h), 5 (2x2,5) ECTS, Petr Kuznetsov
Objective
Students who complete this module (organized in two UEs de 24h each) will learn how to design distributed algorithms, reason about their correctness, and derive matching complexity bounds.
Syllabus
The primary focus of the module is on understanding of the foundations of distributed computing. The module will discuss basics of synchronization, fault-tolerant shared-memory computations, consensus and transactional memory.
Prerequisites
basic knowledge of mathematics and classical algorithms, including complexity analysis, basic programming skills
Objectives
This Learning Module presents distributed computing and large scale technologies. An illustration will be given by implementing a real large scale distributed system.
Syllabus
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.
24h, 2,5 ECTS , Petr Kuznetsov
Objectives
Understanding of the algorithmic foundations behind modern distributed systems, facing unreliable communication, failures and malicious attacks.
Syllabus
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.
Prerequisites: SLR206 (for theory), SLR203 (for practice)
24h, 2,5 ECTS, Marc Jeanmougin, Xhevahire Tërnava, Théo Zimmermann
Objectives
This course presents the concepts of the DevOps model, which combines the development and operational phases of the software lifecycle in an iterative loop. Each phase is illustrated with the use of appropriate tools.
Syllabus
This course addresses the following topics:
- Plan: issue trackers in forges, etc.
- Code: git, pull requests, code review, etc.
- Build and test: continuous integration, linters, etc.
- Release and deploy: release notes, dependency management, continuous deployment, etc.
- Operate and monitor: infrastructure as code, etc.
- Bots and AI agents
Prerequisites
Some programming experience, ideally which includes writing tests.