Ce projet académique (archivé) a été réalisé dans le cadre du cours 635-1 CONCEPTS AVANCÉS ET TECHNIQUES ACTUELLES dispensé par Jean-Paul Calbimonte à la HES-SO Valais-Wallis. Il explore le paradigme de programmation fonctionnelle avec Scala, en contraste avec la programmation orientée objet en Java. Le projet analyse un dataset de vins blancs du monde entier en appliquant les concepts avancés de Scala.

• Exploration d'un nouveau paradigme : Transition de Java/OOP vers Scala/Fonctionnel
• Maîtrise des concepts Scala : Traits, case classes, pattern matching, immutabilité
• Programmation fonctionnelle : Higher-order functions, collections immutables, composition
• Concurrence moderne : Utilisation des Futures pour les opérations asynchrones

Source : 11-WhiteWine.csv

Le dataset contient des informations sur des vins blancs internationaux avec les attributs suivants :

• Nom du vin avec millésime
• Pays d'origine
• Région viticole
• Producteur/Encaveur
• Note qualitative
• Nombre d'évaluations
• Prix
• Année de production

Le projet respecte les exigences de modélisation imposées par le cours :

• Trait
• Case class (immutabilité)
• Enum

1. WineLoader : Chargement et parsing du CSV
2. Services d'Analyse : 6 services d'exploration de données
3. Future Handler : Exécution asynchrone et mesure de performance
4. Tests Unitaires : Validation des services déterministes

• Service de Filtrage
• Service de Tri
• Service de Mapping
• Service d'Aplatissement
• Service de Groupement
• Service de Réduction

Conformément aux bonus demandés dans le cours, le projet utilise les Future pour l'exécution asynchrone :

• Immutabilité : Toutes les structures de données sont immutables
• Fonctions Pures : Pas d'effets de bord dans les services d'analyse
• Composition : Les services peuvent être composés ensemble
• Pattern Matching : Gestion élégante des cas avec match

Le cours de Jean-Paul Calbimonte met l'accent sur la gestion robuste des erreurs avec les types Option et Try.

Le projet inclut des tests unitaires pour valider le comportement déterministe des services.

Le projet inclut un système de benchmarking pour mesurer :

• Les temps d'exécution des services en mode parallèle (via Future)
• Les performances individuelles de chaque traitement

• Scala 3.1.3+ (version utilisée dans le cours)
• SBT (Simple Build Tool) 1.x
• JVM 11+
• VSCode avec extension Metals (recommandé par le cours)

White-Wine/
├── src/
│   ├── main/
│   │   └── scala/
│   │       ├── models/          # Case classes et traits
│   │       ├── services/        # Services d'analyse
│   │       ├── loaders/         # Chargement des données
│   │       └── Main.scala       # Point d'entrée
│   └── test/
│       └── scala/
│           └── services/        # Tests unitaires
├── data/
│   └── 11-WhiteWine.csv        # Dataset
├── build.sbt                   # Configuration SBT
└── README.md

• ✅ Tests Unitaires pour les services déterministes
• ✅ Futures pour l'exécution asynchrone de tous les services
• ✅ Benchmarking avec calcul des temps d'exécution
• ✅ Gestion d'erreurs robuste avec pattern matching

• Case Classes et Traits pour la modélisation (exigence du cours)
• Pattern Matching extensif avec match (obligatoire)
• Collections Immutables (List, Map, Set) - principe fondamental
• Higher-Order Functions (map, filter, fold) - programmation fonctionnelle
• Fonctions Anonymes et Lambdas (λ-calculus vu en cours)
• Option Types pour éviter les NullPointerException
• Future et Concurrence (bonus demandé)
• Companion Objects et méthodes apply
• Enums Scala 3 (version utilisée dans le cours)
• Immutabilité et Composabilité (paradigme fonctionnel)

Ce projet démontre les concepts enseignés par Jean-Paul Calbimonte :

Le cours introduit le λ-calculus comme fondement de la programmation fonctionnelle :

// λx . x + x devient en Scala :
val duplicate = (x: Int) => x + x

// Composition de fonctions (vue en cours)
val addThenDouble = (x: Int) => duplicate(x + 1)

Comparaison directe avec les exemples du cours :

// Style impératif (à éviter)
var total = 0
for (wine <- wines) {
  if (wine.rating > 4.0) total += 1
}

// Style fonctionnel (encouragé dans le cours)
val total = wines.filter(_.rating > 4.0).length

Application des principes vus en cours avec les collections Scala :

// Collections immutables (principe clé du cours)
val originalWines = List(wine1, wine2, wine3)
val filteredWines = originalWines.filter(_.country == "France")
// originalWines reste inchangé

Projet réalisé dans le cadre du cours 635-1 CONCEPTS AVANCÉS ET TECHNIQUES ACTUELLES
Enseignant : Jean-Paul Calbimonte, HES-SO Valais-Wallis
Contexte : Exploration du paradigme fonctionnel avec Scala en transition depuis Java/OOP