Programmation Fonctionnelle — Scala
Du paradigme fonctionnel pur jusqu'au modèle d'acteurs Akka. Six chapitres + une annexe Petri nets. L'examen demande la compréhension du code, pas le par-cœur de la syntaxe.
★ Indications de la prof
- « Un exo sur Petri nets et un second sur un code Scala à comprendre. »
- « Deux feuilles recto-verso autorisées »
- « même police 6 permises »
- « Il ne s'agit pas d'apprendre la syntaxe de Scala. »
- « Exo 1 → Petri nets (pas d'exemples avant) »
- « Exo 2 → refaire les exos du cours et les TDs »
Pas besoin de mémoriser la syntaxe. Il faut savoir lire un code Scala et expliquer ce qu'il fait — typages, évaluations, pattern matching, récursion, opérations sur collections.
Exo 1 — réseaux de Petri : pas de pré-requis cours, donc consulter l'annexe dédiée.
Exo 2 — repasser tous les TDs (Scala_01 à Scala_04, série complexité, ActorCalcul).
i. Les six chapitres
Chaque chapitre a son encre signature. Clique pour entrer.
Paradigme fonctionnel
Pas d'effet de bord, val/var, lazy, tuples, Option[T], hiérarchie Scala.
Fonctions
Déclaration, by value vs by name, first-class citizens, currification, pattern matching.
Programmation objet
Classes, objects, companion, traits, héritage, case classes, abstract.
Collections
List, Seq, Set, Map. map/filter/reduce/fold, lazy eval, collections parallèles.
Complexité
Complexité temporelle, classes O, analyse des structures FP, récursion vs itération.
Akka — Acteurs
Modèle d'acteurs, messages, ActorSystem, problème des philosophes.
ii. Annexe — Petri nets (sujet de l'Exo 1)
Sujet annoncé par la prof comme « pas d'exemples avant ». Notre annexe couvre théorie, notation, propriétés et exemples standards.
iii. Pages compagnons
Concepts & compréhension de code (pas du par-cœur de syntaxe).
Deck complet
Cartes axées sur la compréhension : sémantique, comportement, choix de design.
Lecture & explication
Sélection de bouts de code Scala des TDs avec décortication ligne par ligne. Format type exo 2.
Feuille — Petri & concepts FP
Petri nets + paradigme fonctionnel + types, fonctions, pattern matching. Imprimable.
Feuille — POO, Collections & Akka
Classes, traits, opérations sur collections, modèle d'acteurs. Imprimable.
iv. Format de l'examen
- Sujet ouvert : la prof a précisé « pas d'exemples avant »
- S'appuyer sur l'annexe Petri nets
- Savoir : modéliser, calculer un tirage, identifier marquage atteignable
- « Refaire les exos du cours et les TDs »
- Lire un code et expliquer ce qu'il fait, type de retour, effet, comportement
- Pas du par-cœur de syntaxe — de la lecture active
v. Cartographie CM ↔ TD
Chaque cours a son TD miroir — la prof insiste : refaire les exos des TDs.
| Cours | TD | Contexte pratique |
|---|---|---|
| CM1 | Scala_01_TD | REPL, types, val/var, Option, tuples, basics_scala |
| CM2 | Scala_02_TD | Fonctions, by-name, pattern matching, currification |
| CM3 | Scala_03_TD | Classes, companion, traits, case classes |
| CM4 | Scala_04_TD | Manipulation de listes, map/filter/fold, collectionBis |
| CM5 | Série 1 | Analyse de complexité, exos sur cours_theorique |
| CM6 | ActorCalcul · philosophes | Akka — projet d'acteur, problème des philosophes |
📅 Plan de révision suggéré
| Phase | Action |
|---|---|
| J-7 à J-5 | Lis les 6 chapitres en survol, focus sur la compréhension. Étudie l'annexe Petri nets en profondeur. |
| J-5 à J-3 | Refais tous les TDs sans regarder la correction d'abord. Note les blocages. |
| J-3 à J-2 | Ouvre les flashcards globales · entraîne-toi sur Lire le code. |
| J-2 | Recopie à la main tes deux feuilles recto-verso. Ajoute des post-its perso si besoin. |
| J-1 | Refais un exercice Petri nets et un code à expliquer. Conditions réelles. |
| J | Relis tes deux feuilles. Respire. |
🔮 Prédiction d'examen
Modalité : 50 % partiel écrit + 50 % projet (projet déjà rendu).
- Exo 1 — Code Scala à comprendre : on te donne un programme Scala, tu dois en tracer l'exécution, identifier les patterns utilisés (pattern matching, higher-order, récursion, traits…) et répondre à des questions sur son comportement.
- Exo 2 — Réseau de Petri : modélisation et/ou analyse d'un réseau (places, transitions, marquages, tirs, détection de deadlock).
L'exo 1 absorbe l'essentiel de la matière Scala vue en cours (CM1 à CM6), l'exo 2 mobilise uniquement l'annexe Petri.
| Chapitre | Rôle dans l'exam | Ce qu'il faut savoir reconnaître / tracer |
|---|---|---|
| CM1 — Intro | Lecture (exo 1) | Syntaxe : val/var, types Int/Double/Option, lambda (x) => …, def avec type de retour. |
| CM2 — Fonctions | Lecture (exo 1) | Récursion terminale (@tailrec), fonction d'ordre supérieur, application partielle, currying. Savoir tracer une récursion à la main. |
| CM3 — POO | Lecture (exo 1) | Case classes, traits, classes abstraites, pattern matching (case Cons(...) =>, case Nil =>, case _ =>) — c'est le concept Scala le plus discriminant à reconnaître. |
| CM4 — Collections | Lecture (exo 1) | map, filter, fold/reduce, flatMap, sortBy, groupBy. Trace ce que retourne chaque opération sur la List donnée. |
| CM5 — Complexité | Question annexe possible | Big O d'une fonction Scala donnée — peut servir de sous-question dans l'exo 1. |
| CM6 — Akka | Lecture (exo 1) — si présent | Si le code utilise Actor / ! / receive, identifier le flux de messages entre acteurs. |
| Annexe — Réseaux de Petri | Exo 2 dédié | Le plus rentable à réviser : places, transitions, arcs entrants/sortants, poids, marquage initial, condition de tir, graphe d'accessibilité, deadlock. Format type : « voici un Petri net, montre l'évolution du marquage après les tirs t1, t2, t3 » ou « ce réseau est-il borné / vivant ? ». |
- Si 50/50 : Petri pèse autant que tout Scala — ROI maximal de réviser Petri
- Si 60/40 en faveur de Scala : la lecture de code reste dominante mais Petri compte encore beaucoup