Paradigmes de programmation

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.

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.

Durée estimée

1. ~ 12 à 15 heures.

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.

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

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.

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).

Comparaison des Paradigmes de Programmation