Programmation Évènementielle et IHM II

3 crédits (45 heures)
CM, TD, TP, TPE

Introduction Générale : Le Pont entre Théorie et Pratique

Ce cours représente l’étape cruciale où les étudiants passent de la maîtrise des concepts fondamentaux à la création d’applications professionnelles complètes. Alors que le premier module se concentrait sur les mécanismes de base de la programmation évènementielle (événements, gestionnaires, cycles de vie), ce second module s’attaque aux défis réels du développement logiciel moderne.

L’objectif n’est plus simplement de faire fonctionner du code, mais de créer des applications robustes, maintenables et professionnelles qui répondent à des besoins métier concrets. Ce cours intègre la dimension industrielle du développement logiciel : architecture logicielle, qualité du code, déploiement et intégration avec des systèmes existants.

Ce qui distingue ce module :

Approche holistique : Du code à la distribution en passant par la base de données
Choix technologiques éclairés : Comprendre quand utiliser une application desktop vs web
Production-ready : Aller au-delà du “ça marche” vers le “ça évolue et se maintient”
Contexte professionnel : Simuler les contraintes et bonnes pratiques du monde réel

Plan Détaillé du Cours

Module 1 : Concepts de la programmation orientée objets (9 heures)

CM (3h) : Fondements théoriques - L’Art de Modéliser le Réel

Contexte et importance :
La programmation orientée objet (POO) n’est pas simplement une technique de codage, mais une méthodologie de pensée qui permet de modéliser des systèmes complexes en les décomposant en objets interactifs. Dans le contexte professionnel actuel, la POO est le fondement de toutes les grandes architectures logicielles.

Encapsulation : La protection des données
Le principe fondamental est de protéger l’intégrité des données en contrôlant comment elles sont modifiées. Prenons l’exemple d’un compte bancaire : sans encapsulation, n’importe quelle partie du code pourrait modifier le solde directement, risquant des incohérences. Avec l’encapsulation, chaque modification passe par des méthodes contrôlées qui peuvent valider les opérations.

// Mauvaise pratique : accès direct aux données
compte.solde = -1000; // Impossible dans la réalité !

// Bonne pratique : validation via des méthodes
compte.Retirer(1000); // La méthode vérifie si le solde est suffisant

Héritage : La réutilisation intelligente
L’héritage permet de créer des relations “est-un” entre classes. Par exemple, un CompteEpargne est un CompteBancaire mais avec des fonctionnalités supplémentaires (calcul d’intérêts). Cependant, il faut éviter les hiérarchies trop profondes qui créent des dépendances complexes.

Polymorphisme : La flexibilité architecturale
Le polymorphisme permet de traiter des objets de différentes classes de manière uniforme. Dans une entreprise, un système de paie pourrait traiter des Employe, Manager, et Directeur via une interface commune ICalculableSalaire, même si le calcul diffère pour chaque type.

Abstraction : Gérer la complexité
L’abstraction consiste à se concentrer sur ce qu’un objet fait plutôt que comment il le fait. Une interface IPrintable définit qu’un objet peut être imprimé, sans se soucier de savoir si c’est une imprimante laser ou jet d’encre qui effectue le travail.

TD (3h) : Applications pratiques - De la théorie au design

Exercice concret : Système de bibliothèque
Les étudiants conçoivent un système où :

Un Livre a des propriétés (titre, auteur, ISBN)
Un Emprunt gère la relation entre un Utilisateur et un Livre
Des règles métier s’appliquent (retard, pénalités)

L’objectif est de faire émerger naturellement les concepts POO :

Comment modéliser la relation entre livre et emprunt ?
Où placer la logique de calcul des pénalités ?
Comment gérer les différents types d’utilisateurs (étudiants, professeurs) ?

UML comme outil de communication
Les diagrammes de classes UML ne sont pas simplement des dessins, mais des outils de communication entre développeurs. Un bon diagramme permet de :

Visualiser les relations entre classes
Identifier les dépendances problématiques
Faciliter les discussions d’architecture

TP (3h) : Atelier de codage - Refactoring vers la qualité

Scénario réaliste :
Les étudiants reçoivent un code procédural fonctionnel mais difficile à maintenir (une application de gestion de contacts avec des fonctions longues, des variables globales, peu de structure).

Processus de refactoring :

Identifier les responsabilités : Quel code gère les données ? L’affichage ? La logique métier ?
Créer des classes : Contact, GestionContacts, InterfaceUtilisateur
Encapsuler les données : Rendre les champs privés, ajouter des méthodes publiques
Améliorer la lisibilité : Remplacer les booléens par des enums, nommer les constantes

Compétence clé développée :
La capacité à lire et comprendre du code existant est aussi importante que d’en écrire. Ce TP prépare les étudiants aux réalités du monde professionnel où ils passeront plus de temps à maintenir du code existant qu’à en créer de nouveau.

Module 2 : Programmation orientée objets dans la pratique (9 heures)

CM (3h) : Patterns de conception et bonnes pratiques - L’Expertise Architecturale

Comprendre les patterns comme des solutions éprouvées
Les patterns de conception ne sont pas des recettes magiques, mais des solutions documentées à des problèmes récurrents. Chaque pattern répond à un contexte spécifique :

Singleton : Quand vous avez besoin d’une seule instance globale (gestionnaire de configuration, pool de connexions)
Factory : Quand la création d’objets devient complexe ou doit être centralisée (création de documents selon leur type)
Observer : Quand des objets doivent réagir aux changements d’autres objets (interface utilisateur qui se met à jour quand les données changent)

Les principes SOLID : La fondation de la qualité logicielle
Ces principes, formulés par Robert C. Martin, sont les piliers du code maintenable :

Single Responsibility : Une classe modifiée pour une seule raison. Exemple : une classe CalculateurImpots ne devrait pas aussi gérer l’affichage des résultats.
Open/Closed : Pouvoir étendre le comportement sans modifier le code existant. Exemple : ajouter un nouveau type de paiement sans toucher au système existant.
Liskov Substitution : Si Canard hérite de Oiseau, alors partout où on attend un Oiseau, un Canard doit fonctionner. Sinon, l’héritage est mal utilisé.
Interface Segregation : Mieux vaut plusieurs petites interfaces spécifiques qu’une grosse interface fourre-tout.
Dependency Inversion : Dépendre des abstractions (interfaces) plutôt que des implémentations concrètes. Cela facilite les tests et les changements.

Gestion des exceptions : La robustesse professionnelle
Dans le monde réel, les erreurs arrivent. Une application professionnelle doit :

Anticiper les problèmes possibles (fichier introuvable, connexion perdue)
Gérer les erreurs de manière élégante (messages utilisateur clairs, pas de crash)
Logger les erreurs pour le débogage futur
Récupérer quand c’est possible (retry mechanism)

TD (3h) : Études de cas - Analyser des architectures réelles

Étude de code open source :
Les étudiants analysent des dépôts GitHub populaires (ASP.NET Core, Entity Framework) pour identifier :

Quels patterns sont utilisés et pourquoi ?
Comment les principes SOLID sont appliqués ?
Quelles sont les solutions aux problèmes complexes ?

Conception d’un système de commerce électronique :
Un exercice de conception où les étudiants doivent modéliser :

Les produits et catégories
Le panier et le processus de commande
Les méthodes de paiement
La gestion des stocks

Les défis incluent :

Comment gérer les promotions qui s’appliquent à certains produits ?
Comment structurer le code pour facilement ajouter de nouvelles méthodes de paiement ?
Comment séparer la logique métier de l’interface utilisateur ?

TP (3h) : Projet pratique - Construire un système flexible

Système de notifications avec Observer :
Les étudiants implémentent un système où :

Des Abonnés peuvent s’inscrire à des Publications
Quand une publication est mise à jour, tous les abonnés sont notifiés
Différents types d’abonnés (email, SMS, push) réagissent différemment

Apprentissage clé :
Comprendre comment découpler les composants. La publication ne sait pas comment les notifications sont envoyées, elle se contente de notifier. Cela permet d’ajouter de nouveaux types de notifications sans modifier la publication.

Application avec gestion d’erreurs robuste :
Les étudiants développent une application qui :

Gère les erreurs de saisie utilisateur avec des messages clairs
Récupère des erreurs réseau avec des tentatives de reconnexion
Loggue les erreurs critiques dans un fichier
Fournit un mode dégradé quand certaines fonctionnalités échouent

Module 3 : Applications Windows, resp. applications Web (12 heures)

CM (4h) : Architecture et frameworks - Choisir la bonne plateforme

Applications Windows Desktop : Quand et pourquoi ?
Les applications desktop restent pertinentes dans de nombreux scénarios professionnels :

Performance : Accès direct au matériel, traitement de données intensif
Hors-ligne : Fonctionnement sans connexion internet
Intégration système : Accès aux périphériques, aux dossiers locaux, aux services Windows
Expérience utilisateur riche : Interfaces complexes avec animations fluides

WPF vs WinForms : Le choix stratégique

WinForms : Plus simple, idéal pour des applications métier internes, migration facile depuis VB6
WPF : Plus moderne, séparation stricte entre logique et présentation (MVVM), interfaces riches avec animations et styles

Applications Web : L’ubiquité moderne
Le web domine le paysage applicatif pour des raisons fondamentales :

Accessibilité : Fonctionne sur n’importe quel appareil avec un navigateur
Maintenance centralisée : Mise à jour serveur sans installation client
Coûts réduits : Pas de déploiement sur des milliers de machines
Évolutivité : Peut servir des millions d’utilisateurs avec l’infrastructure appropriée

ASP.NET Core : L’architecture moderne
ASP.NET Core représente une refonte complète avec :

Cross-platform : Fonctionne sur Windows, Linux, macOS
Hautes performances : Concurrence avec Node.js et Go sur certains benchmarks
Modulaire : Ajouter uniquement les composants nécessaires
Intégration avec les SPA : API backend pour Vue.js, React, Angular

Le choix desktop vs web : Une décision métier
Ce choix ne doit pas être technique mais basé sur les besoins :

Critère	Desktop recommandé	Web recommandé
Utilisateurs	Nombre limité (entreprise)	Grand public
Connexion internet	Peu fiable ou absente	Toujours disponible
Performance	Calculs intensifs	Standard
Sécurité	Données sensibles locales	Données centralisées
Maintenance	Équipe IT dédiée	Centralisée

TD (4h) : Conception d’interfaces - L’expérience utilisateur comme priorité

Wireframing professionnel :
Les étudiants apprennent à créer des maquettes avec Figma en considérant :

Hiérarchie visuelle : Qu’est-ce qui attire l’œil en premier ?
Flux utilisateur : Comment l’utilisateur accomplira sa tâche ?
Consistance : Mêmes conventions à travers toute l’application
Feedback : Comment l’interface réagit aux actions de l’utilisateur ?

Accessibilité : Un impératif légal et moral
Les applications professionnelles doivent être utilisables par tous, y compris :

Les personnes malvoyantes (lecteurs d’écran)
Les personnes ayant des difficultés motrices (navigation au clavier)
Les daltoniens (choix de couleurs)

Les normes WCAG (Web Content Accessibility Guidelines) définissent des critères précis :

Contraste minimum entre texte et arrière-plan
Alternatives textuelles pour les images
Navigation possible sans souris
Temps suffisant pour lire le contenu

TP (4h) : Développement pratique - Du design au code fonctionnel

Application WPF : Gestion de tâches
Les étudiants développent une application desktop complète avec :

Interface moderne avec styles et templates
Vue liste des tâches avec priorités colorées
Formulaire d’ajout avec validation
Sauvegarde locale des données

Application web ASP.NET Core : Blog simple
Une application web avec :

Pages Razor pour le contenu statique
Base de données SQLite pour les articles
Formulaire de contact avec validation
Responsive design pour mobiles

Objectif pédagogique :
Comprendre les différences fondamentales entre les deux approches :

En desktop, on pense en termes de fenêtres et contrôles
En web, on pense en termes de pages et requêtes HTTP
Les cycles de vie sont complètement différents

Module 4 : Distribuer les applications (Setup) (9 heures)

CM (3h) : Méthodes de déploiement - Livrer la valeur

Applications Desktop : Le défi de l’installation
Dans le monde professionnel, distribuer une application desktop implique :

Packaging : Regrouper tous les fichiers nécessaires (exécutables, DLLs, ressources)
Installation : Copier les fichiers, créer des raccourcis, configurer le registre
Mises à jour : Mécanisme pour mettre à jour sans réinstaller complètement
Désinstallation : Nettoyer proprement tous les fichiers et paramètres

ClickOnce : La simplicité Microsoft
ClickOnce résout de nombreux problèmes :

Installation depuis une URL ou partage réseau
Mises à jour automatiques vérifiées au démarrage
Isolation des applications (évite les conflits de DLLs)
Permissions minimales par défaut

Applications Web : Le déploiement continu
Le déploiement web moderne suit la philosophie DevOps :

Infrastructure as Code : Définir l’infrastructure dans des fichiers (Docker, Terraform)
CI/CD : Intégration continue et déploiement continu automatisés
Blue/Green deployment : Déployer sur un environnement parallèle avant de basculer
Feature flags : Activer des fonctionnalités progressivement

Sécurité du déploiement :
Un déploiement professionnel doit garantir :

Intégrité : L’application n’a pas été modifiée en route (signature de code)
Confidentialité : Les données sensibles ne sont pas exposées (variables d’environnement)
Authenticité : L’application vient bien de la source légitime (certificats SSL)

TD (3h) : Planification du déploiement - La vision stratégique

Semantic Versioning :
Comprendre la signification des numéros de version :

Major (1.0.0 → 2.0.0) : Changements cassants, API incompatible
Minor (1.0.0 → 1.1.0) : Nouvelles fonctionnalités rétrocompatibles
Patch (1.0.0 → 1.0.1) : Corrections de bugs, pas de nouvelles fonctionnalités

Stratégie de migration :
Quand on change une application existante :

Big Bang : Tout changer d’un coup (risqué mais rapide)
Progressive : Migrer fonctionnalité par fonctionnalité (moins risqué mais complexe)
Parallèle : Exécuter l’ancienne et nouvelle version simultanément (coûteux mais sûr)

TP (3h) : Atelier de déploiement - L’art de livrer

Création d’un installateur MSI :
Les étudiants utilisent WiX Toolset pour :

Créer un fichier .msi professionnel
Ajouter des écrans de bienvenue et licence
Configurer les raccourcis et associations de fichiers
Tester l’installation/désinstallation

Déploiement sur Azure :
Une application ASP.NET Core est déployée sur Azure App Service avec :

Configuration de l’environnement (variables d’environnement)
Connexion à une base de données Azure SQL
Configuration du domaine personnalisé
Mise en place de HTTPS automatique

Objectif professionnel :
Comprendre que le code n’est que 50% du travail. La capacité à livrer, maintenir et faire évoluer une application est tout aussi importante dans le monde professionnel.

Module 5 : Introduction à la programmation bases de données avec ADO.NET 4.0 (6 heures)

CM (2h) : Concepts fondamentaux - Persistance des données

Pourquoi les bases de données ?
Les applications professionnelles doivent persister des données entre les exécutions. Les fichiers texte sont insuffisants car :

Pas de relations entre données
Difficile de requêter efficacement
Pas de concurrence (plusieurs utilisateurs simultanés)
Pas de transactions (tout ou rien)

ADO.NET : L’architecture Microsoft
ADO.NET propose deux modèles complémentaires :

Connected Model : Idéal pour des opérations simples et rapides
- SqlConnection : Gère la connexion à la base
- SqlCommand : Exécute des requêtes SQL
- SqlDataReader : Lit les résultats ligne par ligne (performant mais nécessite la connexion ouverte)
Disconnected Model : Idéal pour des scénarios complexes
- DataSet : Cache de données en mémoire, déconnecté de la base
- DataTable : Table individuelle dans le DataSet
- DataAdapter : Synchronise le DataSet avec la base de données

Sécurité absolue : Les injections SQL
L’erreur la plus grave dans les applications de base de données est de concaténer des chaînes SQL avec des entrées utilisateur :

// DANGEREUX - Vulnérable aux injections SQL
string query = "SELECT * FROM Users WHERE username = '" + username + "'";

// SÉCURISÉ - Utiliser des paramètres
string query = "SELECT * FROM Users WHERE username = @username";
command.Parameters.AddWithValue("@username", username);

Même si l’utilisateur entre ' OR '1'='1 comme nom d’utilisateur, le paramètre sera traité comme une chaîne littérale, pas comme du code SQL.

TD (2h) : Conception de schémas - La structure des données

Normalisation : Éliminer la redondance
La normalisation est un processus pour structurer une base de données :

1NF (Première forme normale) : Pas de groupes répétés, chaque colonne contient une valeur atomique
2NF (Deuxième forme normale) : Dépendance complète de la clé primaire
3NF (Troisième forme normale) : Pas de dépendances transitives

Exemple concret :
Une table Commandes mal conçue :

CommandeID | ClientNom | ClientEmail | Produit1 | Prix1 | Produit2 | Prix2

Normalisée :

Commandes (CommandeID, ClientID, Date)
Clients (ClientID, Nom, Email)
LignesCommande (LigneID, CommandeID, ProduitID, Quantite, PrixUnitaire)
Produits (ProduitID, Nom, Description)

Indexation : La performance
Les index accélèrent les requêtes mais ralentissent les mises à jour. Les bonnes pratiques :

Indexer les colonnes fréquemment utilisées dans WHERE et JOIN
Éviter trop d’index sur les tables très écrites
Utiliser des index composés pour les requêtes multi-colonnes

TP (2h) : Intégration pratique - Du code à la production

Application CRUD complète :
Les étudiants développent une application de gestion d’inventaire avec :

Création, lecture, mise à jour, suppression de produits
Recherche avancée par catégorie et prix
Pagination des résultats
Gestion des erreurs (produit inexistant, données invalides)

Transactions : L’intégrité des données
Un cas d’école : transfert bancaire

using (var transaction = connection.BeginTransaction())
{
    try
    {
        // Débiter le compte source
        // Créditer le compte destination
        transaction.Commit(); // Sauvegarder si tout réussit
    }
    catch
    {
        transaction.Rollback(); // Annuler si erreur
        throw;
    }
}

Apprentissage professionnel :
Comprendre que les bases de données ne sont pas juste du stockage, mais des systèmes transactionnels qui garantissent l’intégrité des données métier. C’est critique dans les applications financières, médicales, ou de gestion.

Modalités d’Évaluation : Vers l’Excellence Professionnelle

Contrôle Continu (40%) - L’Apprentissage Progressif

Participation aux TD/TP (10%) :
Non pas une simple présence, mais une implication active :

Poser des questions pertinentes
Participer aux discussions de conception
Aider ses pairs en difficulté
Documenter son travail

Mini-projets pratiques (20%) :
Chaque module se termine par un mini-projet qui évalue :

La compréhension des concepts clés
La capacité à appliquer les bonnes pratiques
La qualité du code (lisibilité, documentation)
Les tests et robustesse

Quiz théoriques (10%) :
Des questions courtes mais profondes qui testent :

La compréhension des principes plutôt que la mémorisation
La capacité à analyser des scénarios réels
Les choix architecturaux dans différents contextes

Projet Final (TPE) - 60% : L’aboutissement professionnel

Contexte réaliste :
Les étudiants travaillent par équipes de 2-3 sur un projet qui simule un vrai projet client. Ils reçoivent un cahier des charges flou et doivent :

Clarifier les besoins avec un “client” (l’enseignant)
Proposer une solution technique
Estimer les délais et ressources
Développer l’application

Spécifications minimales avec flexibilité :
Plutôt que d’imposer des technologies précises, le cahier des charges définit des objectifs métier :

Gérer des données persistantes
Fournir une interface utilisateur intuitive
Garantir la sécurité des données
Permettre la maintenance future

Livrables professionnels :

Code source avec documentation : Commentaires clairs, README détaillé, architecture expliquée
Rapport technique (10-15 pages) : Décisions architecturales, défis rencontrés, solutions choisies
Présentation orale (15 minutes) : Démonstration fonctionnelle, explication des choix, réponses aux questions

Critères d’évaluation professionnels :

Qualité du code (30%) : Suivi des principes SOLID, gestion des erreurs, tests
Expérience utilisateur (25%) : Interface intuitive, performance, accessibilité
Architecture (25%) : Séparation des responsabilités, évolutivité, sécurité
Présentation (20%) : Clarté, professionnalisme, gestion des questions

Ressources Pédagogiques : Construire une expertise durable

Ouvrages de référence - La bibliothèque idéale

C# 10 and .NET 6 de Mark J. Price :
Pas un simple manuel de syntaxe, mais un guide qui explique pourquoi certaines approches sont meilleures que d’autres. Chaque chapitre inclut des exercices progressifs qui construisent vers un projet final.

Design Patterns: Elements of Reusable Object-Oriented Software (le “Gang of Four”) :
Le livre fondateur sur les patterns de conception. Il ne donne pas des solutions toutes faites, mais un vocabulaire commun pour discuter d’architecture logicielle. Un must-read pour tout développeur sérieux.

Clean Code de Robert C. Martin :
Plus qu’un livre technique, un manifeste sur l’artisanat logiciel. Il enseigne à écrire du code qui n’est pas juste fonctionnel, mais lisible et maintenable. Les principes présentés sont applicables dans tous les langages.

Ressources en ligne - L’apprentissage continu

Microsoft Learn :
La documentation officielle Microsoft, mais structurée comme des cours avec exercices interactifs. Particulièrement forte sur ASP.NET Core et Entity Framework.

Pluralsight :
Des cours vidéo par des experts industriels. Les formations sur WPF par Jeremy Likness et sur ASP.NET Core par Scott Hanselman sont particulièrement recommandées.

GitHub Explore :
Apprendre en lisant du code réel. Les dépôts comme dotnet/aspnetcore et dotnet/efcore montrent comment les experts structurent de grands projets.

Outils professionnels - Travailler comme les experts

Visual Studio 2022 Community :
Pas juste un éditeur de code, mais un environnement de développement complet avec :

Débogueur visuel puissant
Profiler de performance
Outils de test intégrés
Support Git natif

SQL Server Express :
La version gratuite du système de gestion de bases de données professionnel de Microsoft. Parfaite pour apprendre T-SQL et les concepts transactionnels.

Docker Desktop :
L’outil standard pour la conteneurisation. Permet de :

Créer des environnements isolés et reproductibles
Simuler des architectures microservices
Préparer au déploiement cloud

Figma :
L’outil moderne de design d’interfaces. Son approche collaborative permet aux développeurs et designers de travailler ensemble efficacement.

Compétences Acquises : L’employabilité renforcée

À l’issue de ce cours, les étudiants ne possèdent pas juste des connaissances techniques, mais des compétences professionnelles recherchées :

✅ Pensée architecturale : Capacité à concevoir des systèmes complets, pas juste des bouts de code
✅ Qualité logicielle : Prioriser la maintenabilité et la robustesse dès le départ
✅ Décision technique éclairée : Choisir les bons outils pour le bon contexte
✅ Communication technique : Expliquer des choix complexes à des non-techniciens
✅ Gestion de projet agile : Découper un gros problème en tâches réalisables
✅ Adaptabilité technologique : Apprendre rapidement de nouvelles technologies grâce à des fondations solides

Chaque compétence est ancrée dans des exemples concrets et des projets réels, pas dans des théories abstraites.

Perspectives Professionnelles : De l’académique à l’industrie

Métiers accessibles directement après ce cours

Développeur .NET Full Stack :
Salaire débutant : 35-45k€/an en France
Responsabilités : Développer des applications complètes de A à Z, de l’interface utilisateur aux bases de données.

Ingénieur logiciel junior :
Salaire débutant : 40-50k€/an en France
Responsabilités : Participer à la conception d’architectures logicielles, garantir la qualité et la performance.

Spécialisations possibles après ce socle

Cloud computing :
Avec ce cours comme fondation, les étudiants peuvent se spécialiser dans Azure ou AWS, où la demande explose (+25% par an).

DevOps :
Combiner le développement et l’exploitation, avec des salaires moyens de 55-70k€/an pour les profils expérimentés.

Architecte logiciel :
Spécialiste des grandes architectures, salaires de 65-90k€/an, nécessitant une excellente compréhension des principes enseignés dans ce cours.

Tendances du marché

Le marché .NET reste très dynamique :

80% des grandes entreprises françaises utilisent .NET pour leurs applications métier
Croissance de 15% annuelle pour les compétences .NET Core/cloud
Pénurie de talents qualifiés, particulièrement pour les profils full stack

Conclusion : Former des professionnels, pas juste des codeurs

Ce cours va bien au-delà de l’apprentissage de technologies spécifiques. Il forme des professionnels complets capables de :

Comprendre les besoins métier et les traduire en solutions techniques
Concevoir des architectures robustes qui évolueront sur des années
Collaborer efficacement avec des designers, chefs de projet, et autres développeurs
Livrer de la valeur aux clients et utilisateurs finaux

Les technologies enseignées (.NET, WPF, ASP.NET Core) sont importantes, mais les principes fondamentaux (POO, patterns, qualité logicielle) sont éternels. Un étudiant qui maîtrise ces principes pourra s’adapter à n’importe quelle nouvelle technologie.

Dans un monde où le logiciel est partout, ce cours prépare les étudiants non pas juste à trouver un emploi, mais à devenir des leaders techniques capables de créer les systèmes de demain.

Ce programme est régulièrement mis à jour en consultation avec des partenaires industriels pour garantir sa pertinence sur le marché du travail. Les projets sont inspirés de cas réels rencontrés par nos entreprises partenaires.