Langage de programmation
Un langage de programmation est un langage informatique destiné à formuler des algorithmes et produire des programmes informatiques qui les appliquent. D'une manière similaire à une langue naturelle, un langage de programmation est composé d'un alphabet, d'un vocabulaire, de règles de grammaire, de significations, mais aussi d'un environnement de traduction censé rendre sa syntaxe compréhensible par la machine[1],[2].
Les langages de programmation permettent de décrire, d'une part, les structures des données qui seront manipulées par l'appareil informatique, et, d'autre part, d'indiquer comment sont effectuées les manipulations et selon quels algorithmes.
Ils servent de moyens de communication par lesquels le programmeur communique avec l'ordinateur, mais aussi avec d'autres programmeurs ; les programmes étant d'ordinaire écrits, lus, compris et modifiés par une équipe de programmeurs[3].
Plusieurs environnement de développement et agents conversationnels possèdent des fonctionnalités de lecture, interprétation et écriture de programme.
Un langage de programmation est mis en œuvre par un traducteur automatique : compilateur ou interprète. Un compilateur est un programme informatique qui transforme dans un premier temps un code source écrit dans un langage de programmation donné en un code cible qui pourra être directement exécuté par un ordinateur, à savoir un programme en langage machine ou en code intermédiaire[2], tandis que l’interprète réalise cette traduction « à la volée ».
Les langages de programmation offrent différentes possibilités d'abstraction et une notation proche de l'algèbre, permettant de décrire de manière concise et facile à saisir les opérations de manipulation de données et l'évolution du déroulement du programme en fonction des situations.
La possibilité d'écriture abstraite libère l'esprit du programmeur d'un travail superflu, notamment de prise en compte des spécificités du matériel informatique, et lui permet ainsi de se concentrer sur des problèmes plus avancés[2].
Chaque langage de programmation supporte une ou plusieurs approches de la programmation – paradigmes. Les notions induisant le paradigme font partie du langage de programmation et permettent au programmeur d'exprimer dans le langage une solution qui a été imaginée selon ce paradigme.
Les premiers langages de programmation ont été créés dans les années 1950 en même temps que l'avènement des ordinateurs. Cependant, de nombreux concepts de programmation ont été initiés par un langage ou parfois plusieurs langages, avant d'être améliorés puis étendus dans les langages suivants.
La plupart du temps la conception d'un langage de programmation a été fortement influencée par l'expérience acquise avec les langages précédents[4].
Définition
modifierUn langage de programmation est construit à partir d'une grammaire formelle, qui inclut des symboles et des règles syntaxiques, auxquels sont associées des règles sémantiques. Ces éléments sont plus ou moins complexes selon la capacité du langage.
Les modes de fonctionnement et de définition de la complexité d'un langage de programmation sont généralement déterminés par leur appartenance à l'un des degrés de la hiérarchie de Chomsky[5].
Sous un angle théorique, tout langage informatique peut être qualifié de langage de programmation s'il est Turing-complet, c'est-à-dire qu'il permet de représenter toutes les fonctions calculables au sens de Turing et Church (en admettant néanmoins pour exception à la théorie que la mémoire des ordinateurs n'est pas un espace infini)[6].
- Les règles de syntaxe
- Définies par une grammaire formelle, elles régissent les différentes manières dont les éléments du langage peuvent être combinés pour obtenir des programmes[2].
- La ponctuation (par exemple l'apposition d'un symbole ; en fin de ligne d'instruction d'un programme) relève de la syntaxe.
- Le vocabulaire
- Parmi les éléments du langage, le vocabulaire représente l'ensemble des instructions construites d’après des symboles. L'instruction peut être mnémotechnique ou uniquement symbolique comme quand elle est représentée par des symboles d'opérations tels que des opérateurs arithmétiques (« + » et « - ») ou booléens (&& pour le et logique par exemple).
- On parle aussi parfois de mot clé pour désigner une instruction (par abus de langage, car le concept de mot clé ne recouvre pas celui des symboles qui font pourtant eux aussi partie du vocabulaire).
- La sémantique
- Les règles de sémantique définissent le sens de chacune des phrases qui peuvent être construites dans le langage, en particulier quels seront les effets de la phrase lors de l'exécution du programme[2].
- La science l’étudiant est la sémantique des langages de programmation.
- L’alphabet
- L'alphabet des langages de programmation est basé sur les normes courantes comme ASCII, qui comporte les lettres de A à Z sans accent, des chiffres et des symboles[7], ANSI ou Unicode pour la plupart des langages modernes (dans lesquels l'utilisation se limite en général aux chaînes de caractères littérales et aux commentaires, avec quelques exceptions notables comme C♯ qui autorisent également les identifiants unicode).
La plupart des langages de programmation peuvent prévoir des éléments de structure complémentaires, des méthodes procédurales, des définitions temporaires et variables ainsi que des identifiants :
- Les commentaires
- Les commentaires sont des textes qui ne seront pas traduits. Ils peuvent être ajoutés dans les programmes pour y laisser des explications. Les commentaires sont délimités par des marques qui diffèrent d'un langage de programmation à l'autre tels que « -- », « /* » ou « // »[7].
- Les identifiants
- Les éléments constitutifs du programme, tels que les variables, les procédures ou les types servent à organiser le programme et son fonctionnement.
- On peut ainsi, par exemple, diviser un programme en fonctions ou lui donner une structure par objets : ces éléments de structure sont définis par des identifiants ou des procédures par mot clé selon le langage.
Utilisation
modifierUn langage de programmation offre un cadre pour élaborer des algorithmes et exprimer des diagrammes de flux[8],[7].
Il permet, en particulier, de décrire les structures des données qui seront manipulées par l'appareil informatique et quelles seront les manipulations. Un langage de programmation sert de moyen de communication avec l'ordinateur, mais aussi entre programmeurs : les programmes étant d'ordinaire écrits, lus et modifiés par une équipe de programmeurs[3].
Un langage de programmation offre un ensemble de notions qui peuvent être utilisées comme primitives pour développer des algorithmes. Les programmeurs apprécient que le langage soit clair, simple et unifié, qu'il y ait un minimum de notions qui peuvent être combinées selon des règles simples et régulières.
Les qualités d'un langage de programmation influent sur la facilité avec laquelle les programmes pourront être écrits, testés, puis plus tard compris et modifiés[7].
La facilité d'utilisation, la portabilité et la clarté sont des qualités appréciées des langages de programmation.
La facilité d'utilisation, qui dépend de la syntaxe, du vocabulaire et des symboles, influence la lisibilité des programmes écrits dans ce langage et la durée d'apprentissage.
La portabilité permet à un programme écrit pour être exécuté par une plateforme informatique donnée (un système d'exploitation) d'être transféré en vue d'être exécuté sur une autre plateforme[8].
Les programmeurs apprécient que la syntaxe permette d'exprimer la structure logique inhérente au programme. Un des soucis en programmation est d'éviter des pannes, qu'il soit possible de les détecter, les éviter et les rectifier ; ceci est rendu possible par des mécanismes internes des langages de programmation. Des vérifications implicites sont parfois effectuées en vue de déceler des problèmes[8].
Les programmeurs apprécient qu'un langage de programmation soit en ligne avec les bonnes pratiques de programmation et d'ingénierie, qu'il encourage la structuration du programme, facilite la maintenance des programmes et qu'il dissuade, voire interdise les mauvaises pratiques[8].
L'utilisation de l'instruction goto, par exemple, qui existe depuis les premiers langages de programmation, est considérée comme une mauvaise pratique. Son utilisation est déconseillée, voire impossible dans les langages de programmation récents[9].
L'alignement sur les standards industriels, la possibilité d'utiliser des fonctionnalités écrites dans un autre langage de programmation et l'exécution simultanée de plusieurs threads sont des possibilités appréciées des langages de programmation[8].
Notions courantes
modifierUn langage de programmation repose sur un ensemble de notions telles que les instructions, les variables, les types et les procédures ou fonctions, qui peuvent être utilisées comme primitives pour développer des algorithmes[10].
Une instruction
modifierUn ordre donné à un ordinateur[11].
Une variable
modifierUn nom utilisé dans un programme pour faire référence à une donnée manipulée par programme.
Une constante
modifierUn nom utilisé pour faire référence à une valeur permanente.
Une expression littérale
modifierUne valeur mentionnée en toutes lettres dans le programme[10].
Chaque donnée a une classification, celle-ci influe sur la plage de valeurs possibles, les opérations qui peuvent être effectuées et la représentation de la donnée sous forme de bits[10]. Chaque langage de programmation offre une gamme de types primitifs, incorporés dans le langage. Certains langages offrent la possibilité de créer des nouveaux types.
Les types de données primitifs courants sont les nombres entiers, les nombres réels, le booléen, les chaînes de caractères et les pointeurs.
Plus précisément, le type booléen est un type qui n'a que deux valeurs, vrai et faux, tandis que le type pointeur fait référence à une donnée qui se trouve quelque part en mémoire[10].
Une structure de données
modifierUne manière caractéristique d'organiser un ensemble de données en mémoire, qui influe sur les algorithmes utilisés pour les manipuler.
Les structures courantes sont les tableaux, les enregistrements, les listes, les piles, les files et les arbres[12].
Une déclaration
modifierUne phrase de programme qui sert à renseigner au traducteur (compilateur, interpréteur...) les noms et les caractéristiques des éléments du programme tels que des variables, des procédures, de types[3], etc.
Des vérifications sont effectuées au moment de la compilation ou lors de l'exécution du programme, pour assurer que les opérations du programme sont possibles avec les types de données qui sont utilisés. Dans un langage fortement typé, chaque élément du programme a un type unique, connu et vérifié au moment de la compilation, ce qui permet de déceler des erreurs avant d'exécuter le programme[3].
Les procédures, fonctions, méthodes
modifierDivers langages de programmation offrent la possibilité d'isoler un fragment de programme et d'en faire une opération générale, paramétrable, susceptible d'être utilisée de façon répétée. Ces fragments sont appelés procédures, fonctions ou méthodes, selon le paradigme.
Les modules
modifierLes langages de programmation peuvent également offrir la possibilité de découper un programme en plusieurs pièces appelées modules, chacune ayant un rôle déterminé, puis de combiner les pièces[3].
Les notions de procédure et de module sont destinées à faciliter la création de programmes complexes et volumineux en assistant la prise en charge de cette complexité. Ces fonctions permettent en particulier la modularité et l'abstraction[3].
Paradigmes
modifier
Un paradigme est une façon d'approcher la programmation[13]. Chaque paradigme amène sa philosophie de la programmation ; une fois qu'une solution a été imaginée par un programmeur selon un certain paradigme, un langage de programmation qui suit ce paradigme permettra de l'exprimer[14]. Impératif, déclaratif, fonctionnel, logique, orienté objet, concurrent, visuel, événementiel et basé web sont des paradigmes de programmation[13]. Chaque langage de programmation reflète un ou plusieurs paradigmes, apportant un ensemble de notions qui peuvent être utilisées pour exprimer une solution à un problème de programmation[14].
Au cours de l'histoire, les scientifiques et les programmeurs ont identifié les avantages et les limitations d'un style de programmation et apporté de nouveaux styles[13].
La plupart des langages de programmation contemporains permettent d'adopter plusieurs paradigmes de programmation[13] à condition que ceux-ci soient compatibles.
Impératif (ou procédural)
modifierLe paradigme impératif ou procédural est basé sur le principe de l'exécution étape par étape des instructions tout comme on réalise une recette de cuisine. Il est basé sur le principe de la machine de Von Neumann[15].
Un ensemble d'instructions de contrôle de flux d'exécution permet de contrôler l'ordre dans lequel sont exécutées les instructions qui décrivent les étapes.
Le C, le Pascal, le Fortran et le Cobol sont des exemples de langage de programmation qui implémentent le paradigme impératif[14].
Déclaratif
modifierIl y a essentiellement deux paradigmes déclaratifs ; ce sont le paradigme fonctionnel et le paradigme logique. En paradigme fonctionnel, le programme décrit des fonctions mathématiques. En paradigme logique, il décrit des prédicats : c'est-à-dire des déclarations qui, une fois instanciées, peuvent être vraies ou fausses ou ne pas recevoir de valeur de vérité (quand l'évaluation du prédicat ne se termine pas)[13]. Dans un modèle d'implantation, une machine abstraite effectue les opérations nécessaires pour calculer le résultat de chaque fonction[16] ou chaque prédicat. Dans ces paradigmes, une variable n'est pas modifiée par affectation[13]. Une des caractéristiques principales[17] est la transparence référentielle, qui fait qu'une expression peut être remplacée par son résultat sans changer le comportement du programme.
Fonctionnel
modifierLe paradigme fonctionnel a pour principe l'évaluation de formules, afin d'utiliser le résultat pour d'autres calculs ; il s'appuie sur la récursivité et il a pour modèle le lambda-calcul, plus précisément la réduction en forme normale de tête. Tous les calculs évaluent des expressions ou font appel à des fonctions. Pour simplifier[18], le résultat d'un calcul sert pour le calcul ou les calculs qui ont besoin de son résultat jusqu'à ce que la fonction qui produit le résultat du programme ait été évaluée[14]. Le paradigme fonctionnel a été introduit par les langages Lisp et ISWIM ainsi qu'en ce qui concerne les fonctions récursives par Algol 60, dans les années 1960. Des langages tels que Ruby et Scala supportent plusieurs paradigmes dont le paradigme fonctionnel[13], tandis qu'Haskell ne supporte que le paradigme fonctionnel et OCaml privilégie le paradigme fonctionnel qu'il partage avec le paradigme objet et une petite dose d'impératif.
Logique
modifierLe paradigme logique vise à répondre à une question par des recherches dans un ensemble, en utilisant des axiomes, des requêtes et des règles de déduction. L'exécution d'un programme est une cascade de recherches de faits dans un ensemble, en invoquant des règles de déduction. Les données obtenues, peuvent être associées à un autre ensemble de règles et peuvent alors être utilisées dans le cadre d'une autre recherche. L'exécution du programme se fait par évaluation : le système effectue une recherche de toutes les affirmations qui, par déduction, correspondent à au moins un élément de l'ensemble. Le programmeur exprime les règles, et le système pilote le processus[14]. Le paradigme logique a été introduit par le langage Prolog en 1970[13].
Orienté objet
modifierLe paradigme orienté objet est destiné à faciliter le découpage d'un grand programme en plusieurs modules isolés les uns des autres. Il introduit les notions d'objet et d'héritage. Un objet contient les variables et les fonctions en rapport avec un sujet. Les variables peuvent être privées, c'est-à-dire qu'elles peuvent être manipulées uniquement par l'objet qui les contient. Un objet contient implicitement les variables et les fonctions de ses ancêtres, et cet héritage aide à réutiliser du code[13]. Le paradigme orienté objet permet d'associer fortement les données avec les procédures[14]. Il a été introduit par le langage Simula dans les années 1960 et est devenu populaire dans les années 1980, quand l'augmentation de la puissance de calcul des ordinateurs a permis d'exécuter des grands programmes[13]. Divers langages de programmation ont été enrichis en vue de permettre la programmation orientée objet ; c'est le cas de C++ (dérivé du langage C[13]), Simula, Smalltalk, Swift et Java sont des langages de programmation en paradigme orienté objet[14].
Concurrent
modifierEn paradigme concurrent un programme peut effectuer plusieurs tâches en même temps. Ce paradigme introduit les notions de thread, d'attente active et d'appel de fonction à distance[13]. Ces notions ont été introduites dans les années 1980 lorsque, à la suite de l'évolution technologique, un ordinateur est devenu une machine comportant plusieurs processeurs et capable d'effectuer plusieurs tâches simultanément. Les langages de programmation contemporains de 2013 tels que C++ et Java sont adaptés aux microprocesseurs multi-cœur et permettent de créer et manipuler des threads[13]. Plus récemment, on a vu apparaître des langages intégralement orientés vers la gestion de la concurrence, comme le langage Go.
Visuel
modifierDans la grande majorité des langages de programmation, le code source est un texte, ce qui rend difficile l'expression des objets bidimensionnels[13]. Un langage de programmation tel que Delphi ou C# permet de manipuler des objets par glisser-déposer et le dessin ainsi obtenu est ensuite traduit en une représentation textuelle orientée objet et événementielle. Le paradigme visuel a été introduit à la fin des années 1980 par Alan Kay dans le langage Smalltalk, dans le but de faciliter la programmation des interfaces graphiques[13].
Événementiel
modifierAlors qu'un programme interactif pose une question et effectue des actions en fonction de la réponse, en style événementiel le programme n'attend rien et est exécuté lorsque quelque chose s'est passé[13]. Par exemple, l'utilisateur déplace la souris ou presse sur un bouton. Dans ce paradigme, la programmation consiste à décrire les actions à prendre en réponse aux événements. Et une action peut en cascade déclencher une autre action correspondant à un autre évènement[13]. Le paradigme événementiel a été introduit par le langage Simula dans les années 1970. Il est devenu populaire à la suite de l'avènement des interfaces graphiques et des applications web[13].
Basé web
modifierAvec l’avènement de l'Internet dans les années 1990, les données, les images ainsi que le code s'échangent entre ordinateurs. Si un résultat est demandé à un ordinateur, celui-ci peut exécuter le programme nécessaire et envoyer le résultat. Il peut également envoyer le code nécessaire à l'ordinateur client pour qu'il calcule le résultat lui-même[13]. Le programme est rarement traduit en langage machine, mais plutôt interprété ou traduit en une forme intermédiaire, le bytecode, qui sera exécuté par une machine virtuelle, ou traduit en langage machine au moment de l'exécution (just-in-time). Java, PHP et Javascript sont des langages de programmation basée web[13].
Mise en œuvre
modifierL'utilisation d'un langage est rendue possible par un traducteur automatique. Un programme qui prend un texte écrit dans ce langage pour en faire quelque chose, en général soit :
Un programme qui traduit le texte dans un langage qui permettra son exécution, tel le langage machine, le bytecode ou le langage assembleur.
Un programme qui exécute les instructions demandées. Il joue le même rôle qu'une machine qui reconnaîtrait ce langage.
Langage machine
modifierChaque appareil informatique a un ensemble d'instructions qui peuvent être utilisées pour effectuer des opérations. Les instructions permettent d'effectuer des calculs arithmétiques ou logiques, déplacer ou copier des données, ou bifurquer vers l'exécution d'autres instructions. Ces instructions sont enregistrées sous forme de séquences de bits, où chaque séquence correspond au code de l'opération à effectuer et aux opérandes, c'est-à-dire aux données concernées ; c'est le langage machine[19].
La traduction s'effectue en plusieurs étapes. En premier lieu, le traducteur effectue une analyse lexicale où il identifie les éléments du langage utilisés dans le programme. Dans l'étape suivante, l'analyse syntaxique, le traducteur construit un diagramme en arbre qui reflète la manière dont les éléments du langage ont été combinés dans le programme, pour former des instructions. Puis, lors de l'analyse sémantique, le traducteur détermine s'il est possible de réaliser l'opération et les instructions qui seront nécessaires dans le langage cible[20].
Dans le langage de programmation assembleur, des mots aide-mémoire (mnémonique) sont utilisés pour référer aux instructions de la machine. Les instructions diffèrent en fonction des constructeurs et il en va de même pour les mnémoniques. Un programme assembleur traduit chaque mnémonique en la séquence de bits correspondante[21].
Les langages de programmation fonctionnent souvent à l'aide d'un runtime.
Un runtime (traduction : exécuteur) est un ensemble de bibliothèques logicielles qui mettent en œuvre le langage de programmation, permettant d'effectuer des opérations simples, telles que copier des données, mais aussi des opérations beaucoup plus complexes[22].
Lors de la traduction d'un programme vers le langage machine, les opérations simples sont traduites en les instructions correspondantes en langage machine tandis que les opérations complexes sont traduites en des utilisations des fonctions du runtime. Dans certains langages de programmation, la totalité des instructions sont traduites en des utilisations du runtime[22] qui sert alors d'intermédiaire entre les possibilités offertes par la plateforme informatique et les constructions propres au langage de programmation[23].
Chaque langage de programmation a une manière conventionnelle de traduire l'exécution de procédures ou de fonctions, de placer les variables en mémoire et de transmettre des paramètres. Ces conventions sont appliquées par le runtime[24]. Les runtime servent également à mettre en œuvre certaines fonctionnalités avancées des langages de programmation telles que le ramasse-miettes, ou la réflexion[22].
Les langages de programmation sont couramment auto-implémentés, c'est-à-dire que le compilateur pour ce langage de programmation est mis en œuvre dans le langage lui-même. Exemple : un compilateur pour le langage Pascal peut être écrit en langage Pascal[25].
Fonctionnalités avancées
modifierLes fonctionnalités avancées telles que le ramasse-miettes (anglais garbage collector), la manipulation des exceptions, des événements ou des threads, ainsi que la liaison tardive et la réflexion sont mises en œuvre par les runtime des langages de programmation[22].
Un mécanisme qui supprime les variables inutilisées et libère l'espace mémoire qui leur avait été réservé[26].
Un fait inattendu, souvent accidentel, entraîne l'échec du déroulement normal du programme, et ce fait exceptionnel doit être pris en charge par le programme avant de pouvoir continuer. Certains langages de programmation permettent de provoquer délibérément l'arrêt du déroulement normal du programme[27].
Un évènement
modifierUne procédure qui va être exécutée lorsqu'une condition particulière est rencontrée. Les événements sont notamment utilisés pour mettre en œuvre les interfaces graphiques[28].
Une suite d'instructions en train d'être exécutée. Les langages de programmation qui manipulent les threads permettent d'effectuer plusieurs tâches simultanément. Cette possibilité d'exécution simultanée, offerte par les systèmes d'exploitation, est également offerte en allégé par les runtime des langages de programmation[29].
La liaison tardive
modifierLe procédé de liaison (anglais late binding ou dynamic binding) consiste à associer chaque identifiant d'un programme avec l'emplacement de mémoire concerné. Cette opération peut être effectuée lors de la traduction du programme, au cours de l'exécution du programme ou juste avant[30], elle est dite tardive lorsque l'opération de liaison est effectuée très tard, juste avant que l'emplacement concerné ne soit utilisé[31].
La possibilité pour un programme d'obtenir des informations concernant ses propres caractéristiques. Des instructions du langage de programmation permettent à un programme d'obtenir des informations sur lui-même et de les manipuler comme des données[32].
Une structure permettant de manipuler des traits impératifs dans des langages fonctionnels purs.
Historique
modifierBien que la notion de programme apparaisse progressivement au cours de la deuxième moitié du XIXe siècle, les premiers langages de programmation n'apparaissent qu'autour de 1950[33]. Chacun pouvant créer son propre langage, il est impossible de déterminer le nombre total de langages existant à l'heure actuelle.
Utilisations
modifierOn peut aussi classer les langages de programmation en fonction de leur utilisation, car beaucoup de langages sont spécialisés à une application ou à un domaine particulier.
Langages pour pages Web dynamiques
modifierCe type de langage est utilisé pour une plus grande interaction entre un client et un serveur.
Du côté du serveur web, cela permet de produire des pages dont le contenu est généré à chaque affichage. Ces langages sont par ailleurs souvent couplés avec un langage pour communiquer avec des bases de données (exemples : PHP, LiveCode).
Côté client (en général le navigateur web), ces langages offrent la possibilité de réagir à certaines actions de l'utilisateur sans avoir à questionner le serveur. Par exemple, le JavaScript d'une page Web peut réagir aux saisies de l'utilisateur dans un formulaire (et vérifier le format des données).
Certains langages permettent de développer à la fois les aspects client et serveur. C'est le cas d'Ocsigen, de Hop, de Dart ou bien encore du Server-Side JavaScript.
Langages de programmation théorique
modifierOn désigne parfois par langage de programmation théorique les systèmes formels utilisés pour décrire de façon théorique le fonctionnement des ordinateurs. Ils ne servent pas à développer des applications, mais à représenter des modèles et démontrer certaines de leurs propriétés.
On peut citer la machine de Turing et le λ-calcul de Church, qui datent tous les deux des années 1930, et donc antérieurs à l'invention de l'ordinateur. Le λ-calcul a par la suite servi de base théorique à la famille des langages de programmation fonctionnelle. Dans les années 1980, Robin Milner a mis au point le π-calcul pour modéliser les systèmes concurrents.
Langages exotiques
modifierLes langages exotiques ont pour but de créer des grammaires complètes et fonctionnelles, mais dans un paradigme éloigné des conventions. Beaucoup sont d'ailleurs considérés comme des blagues.
Ces langages sont généralement difficiles à mettre en pratique et donc rarement utilisés.
Langages spécialisés
modifier- ABEL, langage pour la programmation électronique des PLD
- CDuce, langage fonctionnel d'ordre supérieur pour la manipulation de documents au format XML.
- Forme de Backus-Naur (BNF), formalisation des langages de programmation
- PROMELA, langage de spécification de systèmes asynchrones
- VRML, description de scènes en trois dimensions
Langages synchrones
modifierLangages de programmation synchrones pour les systèmes réactifs : Esterel, Lustre, Signal.
Langages à vocation pédagogique
modifierLes pseudo-codes ont généralement un but uniquement pédagogique.
- Logo est un langage fonctionnel simple à apprendre.
- Dans les années 1990, le langage BASIC était souvent conseillé pour débuter. Il avait cependant la réputation de favoriser la prise de mauvaises habitudes de programmation.
- Le Processing est un langage simplifié qui s'appuie sur Java. Il permet un développement d'applications fenêtrées sur tout type d'ordinateur équipé de Java.
- L'Arduino est un langage simplifié s'appuyant sur C/C++. Il permet un développement simple de projets électroniques à partir de carte Arduino (AVR).
- L'ArduinoEDU est un langage encore plus simple, en français, pour les grands débutants s'appuyant sur le langage C/C++/Arduino. Il permet un développement très simple de projets électroniques à partir de cartes Arduino (AVR).
- Flowgorithm est un outil de création et modification graphique de programmes informatiques sous forme d'Algorigramme.
Langages pour l'électronique numérique
modifier- Verilog, VHDL : langages de description matérielle, permettant de synthétiser de l'électronique numérique (descriptions de portes logiques) et d'en simuler le fonctionnement
- SystemC, langage de description matérielle de plus haut niveau que les précédents et permettant une simulation plus rapide
Langages pour la statistique
modifierR, SAS et xLispStat sont à la fois un langage de statistiques et un logiciel.
Langages de programmation de Commande Numérique (C.N.)
modifierUne machine-outil automatisée, ou Commande Numérique (C.N.), a besoin d'un langage de programmation pour réaliser les opérations de tournage ou de fraisage…
Langages de programmation des automates programmables industriels (API)
modifier- Sequential function chart, langage graphique, dérivé du grafcet (NB : le grafcet définit les spécifications de façon graphique).
- Langage Ladder, langage graphique.
Langages de programmation audio
modifierNyquist est un langage de synthèse et d'analyse sonore. Pure Data est un logiciel de création musicale graphique qui repose sur un langage de programmation procédural.
Performances
modifierÉtude comparative de 27 langages
modifierSix chercheurs de trois universités portugaises ont mené une étude comparative de 27 langages de programmation, intitulée « Energy Efficiency Across Programming Languages ». Ils ont étudié la consommation d'énergie, le temps d'exécution et l'utilisation de la mémoire. Pour obtenir un ensemble de programmes comparables, les chercheurs ont exploré le Computer Language Benchmarks Game (CLBG).
Le tableau obtenu présente les résultats globaux (en moyenne) pour la consommation d'énergie (Energy), le temps d'exécution (Time) et la consommation maximale de la mémoire (Mb) normalisés par rapport au langage le plus efficace pour le critère mesuré.
Les cinq meilleurs langages sont[34] :
Pour la consommation d'énergie
modifier- C : 1,00
- Rust : 1,03
- C++ : 1,34
- Ada : 1,70
- Java : 1,98
Pour le temps d'exécution
modifier- C : 1,00
- Rust : 1,04
- C++ : 1,56
- Ada : 1,85
- Java : 1,89
Pour la consommation maximale de mémoire
modifierPopularité
modifierLa popularité de chaque langage est difficilement quantifiable ; néanmoins, il existe l'index TIOBE, calculé mensuellement, qui se base sur le nombre de formations/cours destinée aux ingénieurs et le nombre de revendeurs/free-lance spécialisés dans un langage de programmation. C'est une information parcellaire, mais qui peut donner un ordre d'idée sur les tendances en matière de préférence des programmeurs.
Notes et références
modifier- (en) Maurizio Gabbrielli et Simone Martini, Programming Languages: Principles and Paradigms, Springer, [détail des éditions] (ISBN 9781848829138)
- (en) Kenneth C. Louden et Kenneth A. Lambert, Programming Languages: Principles and Practices, Cengage Learning, [détail des éditions] (ISBN 9781111529413)
- (en) William Sims Bainbridge, Berkshire Encyclopedia of Human-computer Interaction, vol. 2, Berkshire Publishing Group LLC, [détail des éditions] (lire en ligne)
- (en) David Anthony Watt et William Findlay, Programming Language Design Concepts, John Wiley & Sons, (ISBN 9780470853207)
- Marcel Cori et Jean-Marie Marandin, « La linguistique au contact de l'informatique : de la construction des grammaires aux grammaires de construction », Histoire Épistémologie Langage, vol. 23, no 1, , p. 49–79 (DOI 10.3406/hel.2001.2817, lire en ligne, consulté le )
- Premiers pas vers une ontologie générale des programmes informatiques, Pascal Lando, Frédéric Fürst, Gilles Kassel et Anne Lapujade, "18es Journées Francophones d'Ingénierie des Connaissances, Grenoble : France (2007)", voir section 3.2 La première catégorie de langages informatiques est celle des langages informatiques généralistes (anglais : general purpose computer languages), c’est-à-dire les langages Turing-complets... Les langages de programmation (anglais : programming languages), ou langages de haut niveau, sont tous les langages généralistes
- (en) Seema Kedar, Programming Paradigms And Methodology, Technical Publications, [détail des éditions] (ISBN 9788184312966)
- (en) I. T. L. Education Solutions Limited, Introduction To Information Technology, Pearson Education India, 2005 (ISBN 9788177581188)
- (en) R. J. Barlow et A. R. Barnett, Computing for Scientists: Principles of Programming with Fortran 90 and C++, John Wiley and Sons, 1998 (ISBN 9780471955962)
- (en) Seema Kedar et Sanjay Thakare, Principles of Programming Languages, Technical Publications, [détail des éditions] (ISBN 9788184315776)
- (en)ADA Programming, Tyrarex Press (ISBN 9781449991999)
- (en) Krishnamurthy, Data Structures Using C, Tata McGraw-Hill Education, 2008 (ISBN 9780070669192)
- ,Arvind Kumar Bansal, Introduction to Programming Languages, CRC Press - 2013 (ISBN 9781466565142)
- (en) Jana, Java And Object-Oriented Programming Paradigm, PHI Learning Pvt. Ltd., [détail des éditions] (ISBN 9788120327757)
- « Le modèle d’architecture de von Neumann », sur interstices.info (consulté le )
- Une machine abstraite pour le paradigme fonctionnel peut être la machine de Krivine.
- Si l'on est dans du fonctionnel pur ou dans du logique pur.
- Dans le cadre de l'appel par nécessité, l'explication qui suit est sommaire.
- (en) D.A. Godse et A.P. Godse, Computer Architecture & Organisation, Technical Publications, (ISBN 8184317719)
- Dhamdhere, Systems Programming and Operating Systems, Tata McGraw-Hill Education, (ISBN 9780074635797)
- (en) Tmh, Computer Science Vii (Tn), Tata McGraw-Hill Education, 2007 (ISBN 9780070668034)
- (en) Michael L. Scott, Programming Language Pragmatics, Morgan Kaufmann, 2009 (ISBN 9780123745149)
- (en) Ian Griffiths, Matthew Adams, .Net Windows Forms in a Nutshell, O'Reilly Media, Inc., 2003 (ISBN 9780596003388)
- (en) Raghavan, Prin Of Compiler Design, Tata McGraw-Hill Education, 2010 (ISBN 9780070144712)
- (en) Diomidis Spinellis et Georgios Gousios, Beautiful Architecture: Leading Thinkers Reveal the Hidden Beauty in Software Design, O'Reilly Media Inc., 2009 (ISBN 9780596517984)
- (en) Chris Smith, Programming F#, O'Reilly Media, Inc., 2009 (ISBN 9780596153649)
- (en) Jeff Friesen, Geoff Friesen, Java 2 by Example, Que Publishing, 2002 (ISBN 9780789725936)
- (en) Harold Davis, Visual Basic 6 Secrets, Harold Davis, 1998 (ISBN 9780764532238)
- (en) Brent B. Welch, Ken Jones, Jeffrey Hobbs, Practical Programming in Tcl and Tk, Prentice Hall Professional, 2003 (ISBN 9780130385604)
- (en) Sibsankar Haldar, Alex A. Aravind, Operating Systems,Pearson Education India - 2010, (ISBN 9788131730225)
- (en) Amit Singh, Mac OS X Internals: A Systems Approach, Addison-Wesley Professional, 2007 (ISBN 9780321278548)
- (en) Kishori Sharan, Harnessing Java 7: A Comprehensive Approach to Learning Java 7, Kishori Sharan, 2011 (ISBN 9781466244641)
- « Une brève histoire des langages de programmation », sur www.albertschool.com (consulté le )
- Programmation : une étude révèle les langages les plus voraces en énergie
Voir aussi
modifier
Articles connexes
modifier- Liste de langages de programmation
- Chronologie des langages de programmation
- Identificateur
- Turing-complet
Liens externes
modifier
- Notices dans des dictionnaires ou encyclopédies généralistes :
