Paradigmes de programmation

Syllabus

1. Description

2. Objectifs

3. Validations de compétences

4. Public cible

   Aucun public cible spécifié pour ce module.

5. Besoins techniques

6. Prérequis

   • Aucun prérequis

7. Niveau

8. Historique du module

   Aucune action enregistrée

Informations générales

1. Public cible

   1. Étudiants en informatique (niveau débutant à intermédiaire).
   2. Développeurs souhaitant élargir leurs connaissances.
   3. Professionnels en reconversion dans le domaine de la programmation.

2. Prérequis

   1. Notions de base en informatique (savoir utiliser un ordinateur).
   2. Connaissance élémentaire d'au moins un langage de programmation est un plus, mais pas obligatoire.

3. Durée estimée

   1. ~ 12 à 15 heures.

4. Objectifs pédagogiques

   1. Comprendre ce qu'est un paradigme de programmation.
   2. Explorer les principaux paradigmes et leur évolution historique.
   3. Maîtriser les concepts clés de chaque paradigme.
   4. Appliquer les paradigmes à des exemples concrets pour résoudre des problèmes.

Modules

1. Introduction à la programmation et aux paradigmes

   1. Histoire et évolution de la programmation

      1. Origines de la programmation

         1. Premières machines programmables et leurs limitations.
         2. Emergence des premiers langages (ex. : Fortran, Lisp).

      2. Evolution vers des langages modernes

         1. Passage des langages de bas niveau aux langages de haut niveau.
         2. Impact des avancées matérielles et des besoins logiciels.

   2. Importance des paradigmes

      1. Pourquoi les paradigmes existent-ils ?

         1. Réponse à des problématiques spécifiques.
         2. Optimisation de la maintenabilité, réutilisabilité et lisibilité du code.

      2. Impact des paradigmes sur les pratiques de développement.

         1. Introduction

   3. Compréhension des langages de programmation

      1. Définition

         Outil pour transmettre des instructions à une machine.

      2. Catégorisation des langages de programmation

         Les langages de programmation peuvent être classifiés selon plusieurs critères, en fonction de leurs caractéristiques, leur mode d'exécution, ou leur paradigme principal.

         Voici les principales catégories :

         1. Par paradigme

            1. Impératifs :Reposent sur des séquences d'instructions qui modifient l'état du programme (ex. : C, Python).
            2. Déclaratifs :Spécifient ce que le programme doit faire, sans indiquer comment (ex. : SQL, HTML).
            3. Fonctionnels : Basés sur l'évaluation de fonctions pures (ex. : Haskell, Lisp).
            4. Orientés objet : Organisation autour des objets, encapsulant données et comportements (ex. : Java, C#).
            5. Logiques : Résolution de problèmes via des règles et faits (ex. : Prolog).
            6. Événementiels : Axés sur la gestion des événements utilisateur ou système (ex. : JavaScript, Visual Basic).

         2. Par méthode d'exécution

            1. Compilés

               1. Convertis en code machine avant leur exécution pour une performance optimale (ex. : C, C++).
               2. Nécessitent un compilateur.

            2. Interprétés

               1. Exécutés directement par un interpréteur sans compilation préalable (ex. : Python, Ruby).

            3. Hybrides

               1. Combinaison des deux approches (ex. : Java, avec son bytecode interprété par la JVM).

         3. Par niveau d'abstraction

            1. Langages de très bas niveau

               1. Langages directement manipulables par le matériel, écrits en langage machine (binaire) compréhensible uniquement par le processeur.
               2. Exemple : Code binaire natif exécuté directement par le CPU.

            2. Langages de bas niveau

               1. Offrent une légère abstraction au-dessus du langage machine, mais nécessitent toujours une bonne connaissance de l'architecture matérielle. Ils permettent un contrôle précis du matériel.
               2. Exemple :Assembleur (x86, ARM).

            3. Langages de haut niveau

               1. Fournissent une abstraction importante par rapport au matériel, permettant aux développeurs de se concentrer sur la logique du programme. Ces langages sont souvent portables entre différentes architectures.
               2. Exemples : C, Java, Python.

            4. Langages de très haut niveau

               1. Conçus pour des tâches ou des domaines spécifiques, avec une syntaxe encore plus abstraite, souvent orientée vers une utilisation simplifiée.
               2. Exemples : MATLAB (calcul scientifique), SQL (bases de données), Scratch (éducation).

         4. Par domaine d'application

            1. Généralistes

               Adaptés à différents domaines (ex. : Python, Java).

            2. Spécifiques

               Conçus pour des tâches précises (ex. : R pour la statistique, Verilog pour la conception matérielle).

         5. Par type de typage

            1. Typage statique

               Les types de données sont vérifiés au moment de la compilation (ex. : C, Java).

            2. Typage dynamique

               Les types de données sont déterminés au moment de l'exécution (ex. : Python, JavaScript).

         6. Par gestion de la mémoire

            1. Manuelle

               Le programmeur gère explicitement l'allocation et la libération de mémoire (ex. : C).

            2. Automatique (Garbage Collection)

               La gestion de la mémoire est prise en charge par l'environnement d'exécution (ex. : Java, Python).

         7. Par support des paradigmes multiples

            1. Monoparadigme

               Conçus pour un seul paradigme (ex. : Haskell pour le fonctionnel).

            2. Multiparadigme

               Prise en charge de plusieurs paradigmes (ex. : Python, JavaScript).

         8. Par génération de langage

            1. Première génération

               Langage machine, utilisé directement par les processeurs.

            2. Deuxième génération

               Assembleur, traduction des instructions machine en mnémotechniques.

            3. Troisième génération

               Langages procéduraux, proches du langage humain (ex. : C, Fortran).

            4. Quatrième génération

               Langages de haut niveau pour des domaines spécifiques (ex. : SQL).

            5. Cinquième génération

               Basés sur la logique ou les contraintes (ex. : Prolog).

         Ces critères de catégorisation permettent de comprendre comment et pourquoi certains langages sont adaptés à des contextes spécifiques. Ce cadre aide également à choisir le langage le mieux adapté pour un projet ou une problématique donnée.

      3. Rôle des langages dans la construction de logiciels modernes

         1. Introduction

2. Aperçu des paradigmes et leur évolution

   1. Aperçu des principaux paradigmes

      • Présentation des styles de programmation

        1. Impératif

           • 1940-1950 : Fondement des premiers langages de programmation, comme Assembly et Fortran.
           • Approche basée sur des instructions séquentielles pour contrôler le flux du programme.

        2. Déclaratif

           • 1950-1960 : Introduite avec des langages comme Lisp (fonctionnelle) et des concepts liés aux bases de données (non procédural).
           • Spécification des résultats attendus.
           • Décrit ce que faire sans spécifier comment faire.

        3. Procédural

           • 1950-1960 : Basée sur l'impératif, elle structure le code en routines ou sous-programmes.
           • Utilisation de sous-programmes.
           • Langages : Fortran, ALGOL.

        4. Fonctionnel

           • 1958 : Apparue avec Lisp, fondée sur les travaux théoriques des lambda-calculs par Alonzo Church (1930-1940).
           • Se concentre sur l'utilisation de fonctions pures et l'immutabilité.
           • Approche déclarative avec fonctions pures.

        5. Logique

           • 1972 : Popularisée avec Prolog. Basée sur la formalisation mathématique des règles logiques.
           • Résolution de problèmes via des règles et faits.

        6. Structuré

           • 1960-1970 : Popularisée par des travaux comme ceux d’Edsger Dijkstra. Introduit des structures de contrôle (boucles, conditionnelles).
           • Langages : ALGOL 60, Pascal, C.
           • Organisation logique et hiérarchisée du code.

        7. Programmation modulaire

           • Années 1970 : Introduit pour améliorer la maintenabilité et l'organisation des logiciels.
           • Concepts influencés par David Parnas (1972). Langages : Modula, Pascal.

        8. Orienté objet (POO)

           • 1967 : Introduite avec Simula 67. Gagne en popularité dans les années 1980 avec Smalltalk, puis C++ et Java.
           • Programmation basée sur des objets.

        9. Événementiel

           • Années 1980 : Émerge avec les interfaces graphiques et les besoins de programmation réactive.
           • Langages : Visual Basic, JavaScript (1995).
           • Réactions aux événements utilisateur.

        10. Programmation concurrente

            • 1960-1980 : Introduite avec les besoins de gestion des processus parallèles dans des systèmes multiprocesseurs.
            • Langages influents : Erlang, Java (avec ses bibliothèques de threads).

        11. Programmation orientée aspect

            • Années 1990 : Développée pour gérer les préoccupations transversales (journalisation, sécurité).
            • Langages : AspectJ.

        12. Programmation orientée composants

            • Années 1990-2000 : Popularisée avec des frameworks comme COM, CORBA, et .NET.

        13. Programmation réactive

            • Années 2000 : Apparue pour répondre aux besoins des interfaces utilisateur modernes et des systèmes réactifs.
            • Langages influents : ReactiveX, Scala (via Akka).

      • Points de vigilance

        • Certains paradigmes (ex. : déclaratif, logique, fonctionnel) apparaissent tôt mais connaissent un développement et une popularité à des moments différents.
        • Des chevauchements existent : par exemple, la programmation structurée et procédurale coexistent dans les années 1960-1970.

   2. Histoire et évolution des paradigmes

      1. Chronologie et innovations clés (voir détail dans chaque paradigme).
      2. Fusion et émergence des paradigmes hybrides dans les langages modernes.

3. Concepts détaillés des paradigmes

   1. Programmation Impérative

      Qu'est-ce que c'est ? : La programmation impérative se concentre sur la manière d'accomplir une tâche en spécifiant de manière détaillée les étapes à suivre pour y parvenir. Les programmes impératifs sont composés d'une séquence d'instructions qui modifient l'état du programme.

      Caractéristiques :

      • Utilisation de variables mutables
      • boucles
      • instructions conditionnelles
      • effets de bord (modification de l'état du programme ou de l'environnement)

      Exemple : Les langages de programmation tels que :

      • C/C++
      • Java
      • Python

      (lorsqu'ils sont utilisés de manière impérative).

   2. Programmation Procédurale

      Qu'est-ce que c'est ? : La programmation procédurale est un sous-ensemble de la programmation impérative qui se concentre sur la structuration du code en utilisant des procédures (ou fonctions) pour diviser le programme en unités réutilisables.

      Caractéristiques :

      • Utilisation de procédures
      • de fonctions
      • et de bibliothèques

      pour organiser le code et le rendre modulaire.

      Exemple : Les langages tels que C, Pascal et Fortran sont souvent utilisés pour la programmation procédurale, où le code est organisé en procédures ou fonctions.

   3. Paradigme structuré

      1. Code organisé en blocs logiques (boucles, conditions).
      2. Langages : Pascal, Python.
      3. Exercice : Écrire un programme de tri.

   4. Programmation modulaire

      Années 1970 : Met l'accent sur l'organisation en modules pour une meilleure maintenabilité (Modula, Pascal, C).

      Programmation Fonctionnelle

      Qu'est-ce que c'est ? : La programmation fonctionnelle se base sur le concept de fonctions mathématiques pures. Les programmes fonctionnels sont composés de fonctions qui prennnent des arguments et renvoient des résultats sans avoir d'effets de bord.

      Caractéristiques :

      • Utilisation de fonctions immuables
      • fonctions de première classe
      • fonctions d'ordre supérieur
      • et évitement des effets de bord

      Exemple : Les langages comme Haskell, Lisp et certaines fonctionnalités de langages comme Python (lorsqu'ils sont utilisés de manière fonctionnelle) et JavaScript (avec ES6) adoptent des aspects de la programmation fonctionnelle.

   5. Paradigme orienté objet

      1. Encapsulation, héritage, polymorphisme.
      2. Langages : Java, Python, C++.
      3. Exercice : Créer une classe pour gérer une bibliothèque.

   6. Paradigme logique

      1. Résolution de problèmes via règles et faits.
      2. Langages : Prolog.
      3. Exercice : Résoudre un puzzle logique.

   7. Paradigme événementiel

      1. Programmation basée sur des événements externes.
      2. Langages : JavaScript.
      3. Exercice : Créer une application réactive.

   8. Programmation logique

      Années 1970 avec Prolog, axée sur les règles logiques pour résoudre des problèmes.

   9. Programmation événementielle

      Années 1980 : Émerge avec les interfaces utilisateur graphiques, notamment via Visual Basic et JavaScript (1995).

4. Comparaison des Paradigmes de Programmation

   Modification de l'état

   • Impératif : Modifie l'état en utilisant des variables mutables.
   • Déclaratif : Ne modifie généralement pas l'état, se concentre sur la description.
   • Procédural : Modifie l'état de manière impérative, mais organise le code en procédures.
   • Fonctionnel : Évite la modification de l'état, utilise des fonctions pures.

   Structure du code

   • Impératif : Les programmes sont structurés autour de séquences d'instructions.
   • Déclaratif : Les programmes décrivent les relations et les objectifs.
   • Procédural : Les programmes sont structurés en utilisant des procédures ou fonctions.
   • Fonctionnel : Les programmes sont basés sur la composition de fonctions.

   Itération

   • Impératif : Utilise des boucles explicites pour l'itération.
   • Déclaratif : Utilise des structures de haut niveau pour l'itération (par exemple, SQL).
   • Procédural : Utilise des boucles, généralement dans le contexte de procédures.
   • Fonctionnel : Utilise la récursivité ou des fonctions de transformation pour l'itération.

   Effets de bord

   • Impératif : Souvent associé à des effets de bord.
   • Déclaratif : Peut avoir des effets de bord, mais ils sont généralement gérés de manière transparente.
   • Procédural : Peut avoir des effets de bord, mais les procédures définissent clairement le contexte.
   • Fonctionnel : Évite les effets de bord.

   Tableau comparatif

   Paradigme	Caractéristiques principales	Exemples de langages
   Impératif	- Spécifie des étapes détaillées pour accomplir une tâche - Utilise des variables mutables, boucles et effets de bord	C, C++, Java, Python (lorsqu'il est utilisé de manière impérative)
   Déclaratif	- Se concentre sur la description de ce que vous voulez obtenir plutôt que sur la manière de l'obtenir - Définit des relations, des contraintes et des objectifs	SQL, HTML, CSS, LaTeX
   Procédural	- Sous-ensemble de la programmation impérative qui organise le code en utilisant des procédures (ou fonctions)	C, Pascal, Fortran
   Fonctionnel	- Basé sur des fonctions mathématiques pures - Utilise des fonctions immuables, de première classe, des fonctions d'ordre supérieur et évite les effets de bord	Haskell, Lisp, Python (avec des aspects fonctionnels), JavaScript (avec ES6)

Exercices, examens et projets