2017-03-17 11:33:14 +01:00
|
|
|
|
Les langages de programmation
|
|
|
|
|
|
=============================
|
|
|
|
|
|
|
2017-04-06 14:55:36 +02:00
|
|
|
|
langage
|
|
|
|
|
|
|
|
|
|
|
|
Un langage de
|
|
|
|
|
|
programmation
|
|
|
|
|
|
doit permettre d' écrire des
|
|
|
|
|
|
programmes de bonne qualité
|
|
|
|
|
|
|
|
|
|
|
|
Un programme doit être :
|
|
|
|
|
|
|
|
|
|
|
|
- correct
|
|
|
|
|
|
- robuste
|
|
|
|
|
|
- lisible, bien documenté
|
|
|
|
|
|
- facile à modifier, extensible
|
|
|
|
|
|
|
|
|
|
|
|
Un langage de programmation doit permettre :
|
|
|
|
|
|
|
|
|
|
|
|
- la programmation structurée
|
|
|
|
|
|
- la structuration avec les types
|
|
|
|
|
|
- proposer un mécanisme d’exceptions
|
|
|
|
|
|
- présenter des caractères de généricité, de polymorphisme et de surcharge
|
|
|
|
|
|
|
|
|
|
|
|
.. important:: La structuration et l'organisation modulaire sert à maintenir de grands programmes,
|
|
|
|
|
|
Elles sont une nécessité
|
|
|
|
|
|
|
2017-03-17 11:33:14 +01:00
|
|
|
|
Approche historique et chronologique
|
|
|
|
|
|
-------------------------------------
|
|
|
|
|
|
|
|
|
|
|
|
- début des langages vers les années 1950 (A0, Fortran(impératif),
|
|
|
|
|
|
Lisp(impératif et fonctionnel), Cobol)
|
|
|
|
|
|
- années 60 : Simula (classes), CPL (compilation séparée)
|
|
|
|
|
|
- années 70 : C (référence du langage impératif de bas niveau), Pascal
|
|
|
|
|
|
(procédures), Smalltalk (programmation orientée objects), Prolog
|
|
|
|
|
|
(programmation logique), Scheme (programmation fonctionnelle pure), Modula,
|
|
|
|
|
|
C++, Ada, Turbo Pascal, Common Lisp, Eiffel (programmation par contrats)
|
|
|
|
|
|
- années 80 : ML, CAML (langages fonctionnels)
|
|
|
|
|
|
- années 90 : Perl, Python, Ruby (languages de scripting multi-paradigmes)
|
|
|
|
|
|
Haskell (fonctionnel pur), Lua, Delphi, Java (orienté objet, machine
|
|
|
|
|
|
virtuelle), PHP (impératif, dédié au web), Erlang (fonctionnel+
|
|
|
|
|
|
programmation concurrente), javascript (orienté web, objets par
|
|
|
|
|
|
prototypage), OCaml (multi-paradigme, fortement typé, orienté sécurité,
|
|
|
|
|
|
programmation générique, fonctionnelle et objets, modulaire et fonctorielle)
|
|
|
|
|
|
- 2009 : go (google, compilé, typage statique, objets par prototypage,
|
|
|
|
|
|
prgrammation concurrente), Rust (fondation mozilla, multiparadigme, programmation concurrente)
|
|
|
|
|
|
|
|
|
|
|
|
Les langages actuellement les plus utilisés dans le monde de l'entreprise sont :
|
|
|
|
|
|
|
|
|
|
|
|
- javascript/NodeJS (70% du code dans le dépôt github) mais victime de son
|
|
|
|
|
|
succès (chaos complet des librairies)
|
|
|
|
|
|
- le go est de plus en plus utilisé, c'est **le** langage qui monte
|
|
|
|
|
|
actuellement
|
|
|
|
|
|
- Python, Ruby, lua, autres langages de scripting (de plus en plus utilisés)
|
|
|
|
|
|
- PHP, Java (stagnants)
|
|
|
|
|
|
- C, C++ (de moins en moins utilisés)
|
|
|
|
|
|
|
|
|
|
|
|
Approche par typologie des langages
|
|
|
|
|
|
-----------------------------------
|
|
|
|
|
|
|
|
|
|
|
|
- **A0 (1954)** : possibilité de découpage de programmes en
|
|
|
|
|
|
sous-programmes ;
|
|
|
|
|
|
|
|
|
|
|
|
- **ALGOL (1958)** : concept de bloc de code (pas forcément nommé) et d'imbrication
|
|
|
|
|
|
de blocs de code ;
|
|
|
|
|
|
|
|
|
|
|
|
- **C (1971)** : syntaxe claire et simple, programme fortement structuré ;
|
|
|
|
|
|
|
|
|
|
|
|
- **C (1980)** : le **code objet**, qui consiste à essayer de faire fonctionner
|
|
|
|
|
|
un seul jeu d'instructions sur des machines différentes. Avant, le code
|
|
|
|
|
|
d'assemblage dépendait du processeur, donc il n'y avait pas un seul et unique
|
|
|
|
|
|
jeu d'instructions ;
|
|
|
|
|
|
|
|
|
|
|
|
- **1980** : déploiement et succès des langages à objets ;
|
|
|
|
|
|
|
|
|
|
|
|
- **1983** : turbo pascal (Borland) qui fut le tournant du C,
|
|
|
|
|
|
propose un IDE (Environnement de Développement Intégré).
|
|
|
|
|
|
aujourd'hui le turbo pascal a pratiquement disparu mais pas totalement,
|
|
|
|
|
|
il est soutenu par une communauté open source autour de **Lazarus** ;
|
|
|
|
|
|
|
|
|
|
|
|
- **depuis les années 90** : deux grands groupes de langages. Les langages à
|
|
|
|
|
|
objets, et les langages fonctionnels. Les deux mondes s'interpénètrent (les
|
|
|
|
|
|
avancées actuelles du web, les microservices (Erlang, Haskell),
|
|
|
|
|
|
viennent du monde fonctionnel, le NoSQL, etc).
|
|
|
|
|
|
Les grandes avancées architecturales (système d'exploitation, linux, etc...)
|
|
|
|
|
|
viennent du monde de l'impératif.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Approches par modèles de programmation
|
|
|
|
|
|
--------------------------------------
|
|
|
|
|
|
|
|
|
|
|
|
- **le mécanisme d'exceptions** : il est possible de rompre l'exécution normale d'un
|
|
|
|
|
|
programme à un endroit et de la reprendre à un autre endroit du programme prévu à
|
|
|
|
|
|
cet effet. Ce mécanisme permet de gérer les situations exceptionnelles.
|
|
|
|
|
|
|
|
|
|
|
|
- **le paradigme impératif** : les entrées-sorties, les modifications physiques de
|
|
|
|
|
|
valeurs et les structures de contrôle itératives sont possibles.
|
|
|
|
|
|
|
|
|
|
|
|
- **le paradigme fonctionnel** : manipule les fonctions comme étant des valeurs du
|
|
|
|
|
|
langage. Celles-ci peuvent être utilisées en tant que paramètres d'autres fonctions
|
|
|
|
|
|
ou être retournées comme résultat d'un appel de fonction.
|
|
|
|
|
|
|
|
|
|
|
|
- **le paradigme objet** : La représentation du programme colle à la réalité en
|
|
|
|
|
|
reproduisant des entités relativement proches des objets réel. Attention, le piège
|
|
|
|
|
|
est de croire qu'il s'agit *du* paradigme universel puisqu'il reproduit en miroir le
|
|
|
|
|
|
réel. **C'est en fait un processus d'abstraction comme un autre**.
|
|
|
|
|
|
|
|
|
|
|
|
Sûreté du langage, typage
|
|
|
|
|
|
~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
|
|
|
|
|
|
|
|
Tri par ordre de sûreté croissant :
|
|
|
|
|
|
|
|
|
|
|
|
0. typage très faible (presque inexistant aujourd'hui) : 42 == "42" == 42.0...
|
|
|
|
|
|
1. typage dynamique faible : (javascript) (possibilité de changer le prototype
|
|
|
|
|
|
d'un objet pendant l'éxécution du programme, c'est la fête on peut faire
|
|
|
|
|
|
n'importe quoi)
|
|
|
|
|
|
2. typage dynamique fort inféré par le comportement (behavior, duck typing)
|
|
|
|
|
|
(python, ruby, PHP) Le contenu de la variable détermine le choix du typage
|
|
|
|
|
|
`var = 0 -> type int`
|
|
|
|
|
|
3. typage statique déclaré fort (Java)
|
|
|
|
|
|
`int var = 0 ;` (pas mal mais super lourd, pas **agile** du tout)
|
|
|
|
|
|
4. langages à types statiques muni d'un moteur d'inférence de types (Ocaml)
|
|
|
|
|
|
sûreté d'exécution, agilité, sécurité.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
La syntaxe, la lisibilité
|
|
|
|
|
|
~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
|
|
|
|
|
|
|
|
Importance de la lisibilité (notamment par rapport aux méthodes agiles).
|
|
|
|
|
|
|
|
|
|
|
|
- courte (python)
|
|
|
|
|
|
- verbeuse (C)
|
|
|
|
|
|
- l'importance des mots clef du langage
|
|
|
|
|
|
- délimiteur de phrase, de blocs (parenthèses, accolades, tabulations, blocs...)
|
|
|
|
|
|
|
|
|
|
|
|
Langages compilés ou interprétés ?
|
|
|
|
|
|
-----------------------------------
|
|
|
|
|
|
|
2017-03-18 15:47:40 +01:00
|
|
|
|
.. glossary::
|
|
|
|
|
|
|
|
|
|
|
|
langage compilé
|
|
|
|
|
|
|
|
|
|
|
|
une première passe est faite, des validations son effectuées **avant**
|
|
|
|
|
|
la génération du code objet, cette phase est faite par le compilateur.
|
|
|
|
|
|
|
|
|
|
|
|
compilateur
|
|
|
|
|
|
|
|
|
|
|
|
programme qui transforme un langage de haut niveau en un langage de base
|
|
|
|
|
|
niveau
|
|
|
|
|
|
|
|
|
|
|
|
- phase d’analyse syntaxique (source -> syntaxe abstraite)
|
|
|
|
|
|
- phase de synthèse (syntaxe abstraite -> code objet)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
scripting (langage de scripting)
|
|
|
|
|
|
|
|
|
|
|
|
langage interprèté
|
|
|
|
|
|
|
|
|
|
|
|
générique (langage)
|
|
|
|
|
|
|
|
|
|
|
|
Langage à usage générique, qui peut être utilisé dans n'importe quel
|
|
|
|
|
|
domaine (par opposition au DSL)
|
|
|
|
|
|
|
|
|
|
|
|
domain specific
|
|
|
|
|
|
|
|
|
|
|
|
Domain Specific Language, langage destiné à être utilisé dans un
|
|
|
|
|
|
domaine prédéfini.
|
|
|
|
|
|
|
|
|
|
|
|
paradigmes
|
|
|
|
|
|
|
|
|
|
|
|
représentation d'une vision particulière à partir d'un modèle théorique
|
|
|
|
|
|
|
|
|
|
|
|
impératif
|
|
|
|
|
|
|
|
|
|
|
|
l'algorithme ressemble à une recette de cuisine,
|
|
|
|
|
|
c'est-à-dire à une succession d'instructions à exécuter
|
|
|
|
|
|
les unes à la suite des autres
|
|
|
|
|
|
|
|
|
|
|
|
fonctionnel
|
|
|
|
|
|
|
|
|
|
|
|
l'algorithme ne dépend plus de l'ordre d'exécution d'instructions
|
|
|
|
|
|
pas de mélange entre les données et les traitements
|
|
|
|
|
|
|
|
|
|
|
|
objets (programmation)
|
|
|
|
|
|
|
|
|
|
|
|
le monde est découpé en catégories
|
|
|
|
|
|
qui permettent de créer des objets
|
|
|
|
|
|
|
|
|
|
|
|
**développement par composants**
|
|
|
|
|
|
|
|
|
|
|
|
les objets sont organisés entre eux par composants suivant des designs patterns,
|
|
|
|
|
|
(patrons de conception)
|
|
|
|
|
|
|
|
|
|
|
|
garbage collector (ramasse miettes)
|
|
|
|
|
|
|
|
|
|
|
|
la gestion automatique de la mémoire apparaît en 1989
|
|
|
|
|
|
|
|
|
|
|
|
machine virtuelle
|
|
|
|
|
|
|
|
|
|
|
|
portabilité du code (mais diminution en optimisation et performances)
|
|
|
|
|
|
|
|
|
|
|
|
JIT (just in time compiler)
|
|
|
|
|
|
|
|
|
|
|
|
code objet, programmes fonctionnant autour de machines virtuelles
|
|
|
|
|
|
|
|
|
|
|
|
|
2017-03-17 11:33:14 +01:00
|
|
|
|
- **le typage statique** : la vérification de la compatibilité entre les types des
|
|
|
|
|
|
paramètres formels et des paramètres d'appel est effectuée au moment de la
|
|
|
|
|
|
compilation du programme. Dès lors, il n'est pas nécessaire de faire ces
|
|
|
|
|
|
vérifications durant l'exécution du programme ce qui accroît son efficacité. En
|
|
|
|
|
|
outre, la vérification de type permet d'éliminer la plupart des erreurs introduites
|
|
|
|
|
|
par maladresse ou étourderie et contribue à la sûreté de l'exécution.
|
|
|
|
|
|
|
|
|
|
|
|
- **le typage dynamique** : la vérification de la compatibilité entre les types des
|
|
|
|
|
|
paramètres formels et des paramètres d'appel est effectuée au moment de l'exécution
|
|
|
|
|
|
ou de l'appel à certaines parties de codes du programme.
|
|
|
|
|
|
|
|
|
|
|
|
- **le polymorphisme paramétrique** : une fonction ou un objet qui n'explore pas la
|
|
|
|
|
|
totalité de la structure d'un de ses arguments accepte que celui-ci ait un type non
|
|
|
|
|
|
entièrement déterminé. Ce paramètre est alors dit polymorphe. Cette particularité
|
|
|
|
|
|
permet de développer un code générique utilisable pour des structures de données
|
|
|
|
|
|
différentes tant que la représentation exacte de cette structure n'a pas besoin
|
|
|
|
|
|
d'être connue par le code en question. L'algorithme de typage est à même de faire
|
|
|
|
|
|
cette distinction.
|
|
|
|
|
|
|
|
|
|
|
|
- **l'inférence de types** : le programmeur n'a besoin de donner aucune information
|
|
|
|
|
|
de type à l'intérieur de son programme. Le langage se charge seul de déduire du code
|
|
|
|
|
|
le type le plus général des expressions et des déclarations qui y figurent. Cette
|
|
|
|
|
|
inférence est effectuée conjointement à la vérification, lors de la compilation du
|
|
|
|
|
|
programme.
|
|
|
|
|
|
|
|
|
|
|
|
Les grands paradigmes de programmation
|
|
|
|
|
|
---------------------------------------
|
|
|
|
|
|
|
|
|
|
|
|
Le paradigme des objets
|
|
|
|
|
|
~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
|
|
|
|
|
|
|
|
- 1962 (SIMULA) : premières notions de classes ;
|
|
|
|
|
|
|
|
|
|
|
|
Pui, une dizaine d'années plus tard :
|
|
|
|
|
|
|
|
|
|
|
|
- C++ : intégration des classes pour le C ;
|
|
|
|
|
|
- turbo pascal : intégration des classes pour le pascal ;
|
|
|
|
|
|
|
|
|
|
|
|
Tous les langages actuels ont intégré des traits objets mais de manière très
|
|
|
|
|
|
différentes :
|
|
|
|
|
|
|
|
|
|
|
|
- perl (1987)
|
|
|
|
|
|
- python (1991)
|
|
|
|
|
|
- Ruby (1993)
|
|
|
|
|
|
|
|
|
|
|
|
- L'implémentation des objets en python est très proche des notions initiales de
|
|
|
|
|
|
classes issues du Smaltalk et présente une tentative très intéressante
|
|
|
|
|
|
d'unification des objets et des types depuis python 2.2 ;
|
|
|
|
|
|
|
|
|
|
|
|
- Java (1995) : très grosse réussite industrielle en surfant sur la vague de la
|
|
|
|
|
|
programmation objet, et des machines virtuelles, mais en fait et avec le recul,
|
|
|
|
|
|
doté d'un support objet lourd et alambiqué.
|
|
|
|
|
|
Le monde Java est lourd, avec des outils consommant beaucoup de mémoire et
|
|
|
|
|
|
qui ne satisfont pas à la règle du KISS (Keep It Simple, Stupid) ;
|
|
|
|
|
|
|
|
|
|
|
|
|
2017-03-17 11:58:08 +01:00
|
|
|
|
Il n'y a pas **une** POO (Programmation Objet), il y a des POO.
|
|
|
|
|
|
Les implémentations objets dans les langages sont riches et variées :
|
2017-03-17 11:33:14 +01:00
|
|
|
|
|
|
|
|
|
|
- objets obligatoirement construits pas des classes (Java, C++, ...)
|
|
|
|
|
|
- objets sans définition de classes (javascript, Ocaml, go, rust)
|
|
|
|
|
|
- langages à attributs (python)
|
|
|
|
|
|
- langages ou le type des objets est défini par leur classe (python, ruby)
|
|
|
|
|
|
- langages ou le type des objets est différent du type de leur classe (Ocaml)
|
|
|
|
|
|
- objets sans classes mais construits par des prototypes (javascript)
|
|
|
|
|
|
- construction d'objets possibles objets sans classe du tout (Ocaml)
|
|
|
|
|
|
- encapsulation des attributs des objets (Java, Ocaml, C++, PHP)
|
|
|
|
|
|
- pas d'encapsulation des attributs (python, ruby, javascript...)
|
|
|
|
|
|
|
|
|
|
|
|
Le paradigme impératif
|
|
|
|
|
|
~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
|
|
|
|
|
|
|
|
Un programme est une suite d'états de la mémoire de l'ordinateur,
|
|
|
|
|
|
c'est la suite logique des machines de Turing.
|
|
|
|
|
|
La plupart des programmeur aujourd'hui raisonnent suivant ce paradigme,
|
|
|
|
|
|
et ont une très faible visibilité par rapport aux autres paradigmes existants.
|
|
|
|
|
|
Seuls les programmeurs cultivés sont aujourd'hui capable de raisonner
|
|
|
|
|
|
suivant différents paradigmes, ce sont des programmeurs chevronnés et
|
|
|
|
|
|
cultivés.
|
|
|
|
|
|
|
|
|
|
|
|
Le paradigme fonctionnel
|
|
|
|
|
|
~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
|
|
|
|
|
|
|
|
La notion de fonction que possède sous une forme ou une autre la plupart des
|
|
|
|
|
|
langages est empruntée aux mathématiques et non à l'électronique. D'une manière
|
|
|
|
|
|
générale, les langages substituent des modèles formels aux conceptions purement
|
|
|
|
|
|
calculatoires. Ils y gagnent en expressivité. Certains langages fondent leur
|
|
|
|
|
|
paradigme de programmation sur l'abstraction entrée-traitement-sortie, donc sur le
|
|
|
|
|
|
**mathème fonctionnel** et pas sur la boite noire électronique. La fonction
|
|
|
|
|
|
mathématique apporte un niveau opératoire dans le traitement de l'information.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Approche par fonctionnalités
|
|
|
|
|
|
----------------------------
|
|
|
|
|
|
|
|
|
|
|
|
Plusieurs domaines de l'informatique on proposé/imposé des méthodologies,
|
|
|
|
|
|
des manières de faire. Ces modèles de programmation on fortement influencé
|
|
|
|
|
|
en retour les langages. On reconnaît aujourd'hui :
|
|
|
|
|
|
|
|
|
|
|
|
- Le modèle client-serveur
|
|
|
|
|
|
- Le modèle de programmation concurrente (exécution de processus légers, threads) :
|
|
|
|
|
|
- Le modèle de développement d'une application de bureau (MVC, ergonomie d'interface)
|
|
|
|
|
|
- Le modèle de développement web (communiquer sur le réseau Internet, API
|
|
|
|
|
|
REST, microservices...)
|
|
|
|
|
|
- Le modèle de programmation système et réseau
|
|
|
|
|
|
- le modèle **Dev Ops** et les méthodes de développement virtualisés
|
|
|
|
|
|
- les langages présentant des **fonctionnalités agiles**
|
2017-04-06 14:55:36 +02:00
|
|
|
|
|
|
|
|
|
|
Conclusion
|
|
|
|
|
|
-----------
|
|
|
|
|
|
|
|
|
|
|
|
Les langages de haut niveau sont caractérisés par
|
|
|
|
|
|
des concepts tels que :
|
|
|
|
|
|
|
|
|
|
|
|
- déclaration de valeurs, types, expressions, portée
|
|
|
|
|
|
- expressions, variables, instructions, structures de contrôle
|
|
|
|
|
|
- fonctions, procédures, fermetures
|
|
|
|
|
|
- encapsulation, modules, objets
|
|
|
|
|
|
|
|
|
|
|
|
=========== ============
|
|
|
|
|
|
Paradigmes Concepts
|
|
|
|
|
|
=========== ============
|
|
|
|
|
|
impératif variables, procédures, modules
|
|
|
|
|
|
objets classes, méthodes, héritage, surcharge
|
|
|
|
|
|
fonctionnel fonctions, fermetures, modules
|
|
|
|
|
|
logique prédicats, modules
|
|
|
|
|
|
concurrent tâche/processus, communication
|
|
|
|
|
|
=========== ============
|
