Langage de programmation

Un langage de programmation est un langage artificiel qui peut être utilisé pour contrôler le comportement d'une machine, en particulier un ordinateur . Les langages de programmation sont définis par syntaxique et règles sémantiques qui décrivent leur structure et leur sens respectivement. De nombreux langages de programmation ont une certaine forme de description écrite de leur syntaxe et la sémantique; certains sont définis par une mise en œuvre officielle (par exemple, un Norme ISO), tandis que d'autres ont une implémentation dominante (par exemple, Perl ).

Les langages de programmation sont également utilisés pour faciliter la communication sur la tâche d'organiser et de manipulation de l'information, et d'exprimer des algorithmes précisément. Certains auteurs limitent le terme "langage de programmation" pour les langues qui peuvent exprimer tous les algorithmes possibles; parfois le terme " langage informatique "est utilisé pour les langues artificielles plus limitées.

Des milliers de différents langages de programmation ont été créés à ce jour, et de nouvelles langues sont créés chaque année.

Définitions

Traits souvent considérées comme importantes pour constituer un langage de programmation:

• Fonction: Un langage de programmation est un langage utilisé pour écrire programmes informatiques, qui impliquent un ordinateur effectuant une sorte de calcul ou algorithme et éventuellement contrôler des appareils externes tels que des imprimantes, des robots, et ainsi de suite.

• Cible: Langages de programmation diffèrent langues naturelles que les langues naturelles ne sont utilisés que pour l'interaction entre les personnes, tandis que les langages de programmation permettent également l'homme de communiquer des instructions aux machines. Certains langages de programmation sont utilisés par un dispositif pour contrôler un autre. Par exemple Programmes PostScript sont souvent créés par un autre programme pour contrôler un imprimante d'ordinateur ou écran.

• Constructions: Les langages de programmation peuvent contenir des constructions pour la définition et la manipulation structures de données ou à commander le flux d'exécution.

• Puissance expressive: Le théorie de calcul classe langues par les calculs qu'ils sont capables d'exprimer. Tous Turing langues complètes peut mettre en œuvre le même ensemble de algorithmes . ANSI / ISO SQL et Charité sont des exemples de langues qui ne sont pas encore Turing souvent appelés langues complètes de programmation.

Langues non-informatiques, tels que des langages de balisage comme HTML ou grammaires formelles comme BNF, ne sont généralement pas considérés comme des langages de programmation. Un langage de programmation (qui peuvent ou peuvent ne pas être Turing complet) peut être incorporé dans ces langues (hôtes) non-calcul.

But

Un objectif important de langages de programmation est de fournir des instructions à un ordinateur. Ainsi, les langages de programmation diffèrent de la plupart des autres formes d'expression humaine en ce qu'elles exigent un plus grand degré de précision et l'exhaustivité. Lorsque vous utilisez un langage naturel pour communiquer avec d'autres personnes, auteurs humains et haut-parleurs peuvent être ambigus et faire de petites erreurs, et encore se attendre leur intention d'être compris. Cependant, au sens figuré, les ordinateurs "font exactement ce qu'on leur dit de faire", et ne peuvent pas «comprendre» ce que le code de la programmation destinée à écrire. La combinaison de la définition de la langue, la programme et les entrées du programme doivent spécifier entièrement le comportement externe qui se produit lorsque le programme est exécuté.

Beaucoup de langues ont été conçus à partir de zéro, modifié pour répondre aux nouveaux besoins, combinée avec d'autres langues, et finalement tombée en désuétude. Bien qu'il y ait eu des tentatives pour concevoir une langue «universelle» de l'ordinateur qui sert toutes fins, tous ont pas réussi à être accepté dans ce rôle. La nécessité pour les langues informatiques divers découle de la diversité des contextes dans lesquels les langues sont utilisées:

• Les programmes vont de petits scripts écrits par des amateurs individuels à d'énormes systèmes écrits par des centaines de programmeurs.
• Les programmeurs vont dans l'expertise des novices qui ont besoin de la simplicité avant tout, à des experts qui peuvent être à l'aise avec une complexité considérable.
• Les programmes doivent équilibrer la vitesse, la taille et la simplicité sur des systèmes allant de microcontrôleurs à superordinateurs.
• Les programmes peuvent être écrites une fois et non pour les générations changent, ou ils peuvent subir des modifications à peu près constante.
• Enfin, les programmeurs peuvent simplement diffèrent dans leurs goûts: ils peuvent être habitués à discuter des problèmes et de les exprimer dans une langue particulière.

Une tendance commune dans le développement des langages de programmation a été d'ajouter plus de capacité à résoudre des problèmes en utilisant un niveau plus élevé de abstraction. Les premiers langages de programmation ont été très étroitement liée au matériel sous-jacent de l'ordinateur. Comme nouveaux langages de programmation ont développé, fonctionnalités ont été ajoutées qui permettent aux programmeurs d'exprimer des idées qui sont plus éloignés de la simple traduction en instructions matérielles sous-jacentes. Parce que les programmeurs sont moins liés à la complexité de l'ordinateur, leurs programmes peuvent faire plus avec moins d'effort informatique du programmateur. Cela leur permet d'écrire plus de fonctionnalités par unité de temps.

Processeurs de langage naturel ont été proposés comme un moyen d'éliminer la nécessité d'un langage spécialisé pour la programmation. Cependant, cet objectif demeure lointain et ses avantages sont ouverts au débat. Edsger Dijkstra a pris la position que l'utilisation d'un langage formel est essentiel pour prévenir l'introduction de concepts vides de sens, et a rejeté la programmation en langage naturel comme "stupide." Alan Perlis était similaire dédaigneux de l'idée.

Éléments

Syntaxe

Parse arbre de code Python avec insert tokenization

La coloration syntaxique est souvent utilisé pour aider les programmeurs dans des éléments de code source reconnaissant. La langue ci-dessus est Python .

La forme de la surface d'un langage de programmation est connu comme son syntaxe. La plupart des langages de programmation sont purement textuelle; ils utilisent des séquences de texte comprenant des mots, des chiffres et des signes de ponctuation, un peu comme les langues naturelles écrites. D'autre part, il existe des langages de programmation qui sont plus graphique dans la nature, en utilisant les relations spatiales entre les symboles de spécifier un programme.

La syntaxe d'un langage décrit les combinaisons possibles de symboles qui constituent un programme syntaxiquement correct. Le sens donné à une combinaison de symboles est assurée par sémantique (soit formelle ou codé en dur dans un mise en œuvre de référence). Comme la plupart des langues sont textuelle, cet article traite de la syntaxe textuelle.

syntaxe du langage de programmation est généralement définie en utilisant une combinaison de expressions régulières (pour structure lexicale), et Backus-Naur Form (pour structure grammaticale). Voici une grammaire simple, basé sur Lisp:

expression ::= atom | list
atom ::= number | symbol
number ::= [+-]?['0'-'9']+
symbol ::= ['A'-'Z''a'-'z'].*
list ::= '(' expression* ')'


Cette grammaire précise ce qui suit:

• une expression est soit un atome ou une liste;
• un atome est soit un chiffre ou un symbole;
• un nombre est une séquence ininterrompue d'un ou plusieurs chiffres décimaux, éventuellement précédé par un signe plus ou moins;
• un symbole est une lettre suivie par zéro ou plusieurs caractères (hors espaces); et
• une liste est une paire assortie de parenthèses, avec zéro ou plusieurs expressions à l'intérieur.

Les exemples suivants sont des séquences symboliques bien formées dans cette grammaire: ' 12345 ',' () ',' (ab c232 (1)) '

Tous les programmes syntaxiquement correctes ne sont pas sémantiquement correcte. De nombreux programmes syntaxiquement correctes sont néanmoins mal formées, selon les règles de la langue; et peut (en fonction de la spécification du langage et la solidité de la mise en œuvre) entraînera une erreur de traduction ou de l'exécution. Dans certains cas, de tels programmes peuvent exposer comportement indéfini. Même quand un programme est bien défini dans une langue, il peut encore avoir un sens qui ne est pas destiné par la personne qui l'a écrit.

Utilisation langage naturel à titre d'exemple, il peut ne pas être possible d'attribuer un sens à une phrase grammaticalement correcte ou de la peine peut être faux:

• " Idées vertes incolores dorment furieusement. "Est grammaticalement bien formé, mais n'a pas de sens généralement admis.
• "John est un célibataire marié." est grammaticalement bien formé mais exprime un sens qui ne peut pas être vrai.

Le fragment du langage C suivante est syntaxiquement correct, mais effectue une opération qui ne est pas sémantiquement défini (car p est un pointeur NULL, les opérations P> réel et p-> im aurait aucun sens):

 complexe * p = NULL;
 abs_p complexe = sqrt (p-> réel * p> real + p-> im * p-> im);

La grammaire nécessaire de spécifier un langage de programmation peut être classé par sa position dans le Hiérarchie de Chomsky. La syntaxe de la plupart des langages de programmation peut être spécifié en utilisant un type-2 grammaire, ce est à dire, ils sont grammaires hors-contexte.

Sémantique statique

Les sémantique statique définit restrictions sur la structure des textes valables qui sont difficiles ou impossibles à exprimer dans formalismes syntaxiques standard. La plus importante de ces restrictions sont couvertes par des systèmes de type.

Type de système

Un système de type définit comment un langage de programmation classe des valeurs et des expressions dans types, comment il peut manipuler ces types et comment ils interagissent. Ceci comprend généralement une description de la des structures de données qui peuvent être construits dans la langue. La conception et l'étude des systèmes de type utilisant les mathématiques formelle est connu comme tapez théorie.

En interne, tous les données aux ordinateurs numériques modernes sont stockés simplement comme des zéros et de uns ( binaires ).

Tapé contre langues non typées

Une langue est tapé si la spécification de chaque opération définit les types de données à laquelle l'opération est applicable, avec l'implication que ce ne est pas applicable à d'autres types. Par exemple, " this text between the quotes "est une chaîne. Dans la plupart des langages de programmation, divisant un nombre par une chaîne n'a pas de sens. La plupart des langages de programmation modernes seront donc rejeter tout programme de tenter d'effectuer une telle opération. Dans certaines langues, l'opération de sens sera détecté lorsque le programme est compilé ("statique" vérification de type), et rejeté par le compilateur, tandis que dans d'autres, il sera détecté lorsque le programme est exécuté ("dynamique" la vérification de type), résultant dans un environnement d'exécution exception.

Un cas particulier de langages typés sont les langues de type unique. Ce sont souvent des scripts ou langages de balisage, comme Rexx ou SGML, et ne ont qu'un seul type de données - le plus souvent des chaînes de caractères qui sont utilisés pour les données symboliques et numériques.

En revanche, une langue non typé, comme la plupart langages d'assemblage, permet à toute opération à effectuer sur les données, qui sont généralement considérés comme des séquences de bits de différentes longueurs. Langages de haut niveau qui sont non typé comprennent BCPL et certaines variétés de Forth.

Dans la pratique, tandis que quelques langues sont considérées tapé du point de vue de tapez la théorie (vérification ou de rejeter toutes les opérations), la plupart des langues modernes offrent un degré de frappe. Beaucoup de langues de production fournissent des moyens de contourner ou de contourner le système de type.

Statique par rapport typage dynamique

En typage statique toutes les expressions ont leurs types déterminés avant le programme en cours d'exécution (généralement au moment de la compilation). Par exemple, 1 et (2 + 2) sont des expressions entières; ils ne peuvent pas être transmises à une fonction qui attend une chaîne, ou stockés dans une variable qui est défini pour tenir les dates.

Langage à typage statique peuvent être dactylographiés ou manifestement saisissez-déduite. Dans le premier cas, le programmeur doit écrire explicitement à certains types positions textuelles (par exemple, à la variable déclarations). Dans le second cas, le compilateur déduit les types d'expressions et déclarations en fonction du contexte. La plupart des grands langage à typage statique, tels que C ++ , C # et Java , sont manifestement tapé. Type complet inférence a traditionnellement été associé avec moins de langues traditionnels, tels que Haskell et ML. Cependant, de nombreuses langues manifestement tapé soutiennent type partiel inférence; par exemple, Java et C # déduire deux types dans certains cas limités typage dynamique, aussi appelé le typage latente, détermine le type-sécurité des opérations lors de l'exécution. en d'autres termes, les types sont associés à des valeurs d'exécution plutôt que des expressions textuelles. Comme avec les langues de type déduit, langages typés dynamiquement ne nécessitent pas le programmeur à écrire des annotations de type explicites sur les expressions. Entre autres choses, cela peut permettre une seule variable pour faire référence à des valeurs de types différents à différents points dans l'exécution du programme. Cependant, les erreurs de type ne peuvent pas être détectés automatiquement jusqu'à un morceau de code est effectivement exécuté, rendant plus difficile le débogage. Ruby, Lisp, JavaScript et Python sont typés dynamiquement.

Typage faible et forte

Typage faible permet une valeur d'un type à traiter comme un autre, par exemple le traitement d'une chaîne comme un certain nombre. Cela peut parfois être utile, mais il peut également permettre à certains types de défauts du programme de passer inaperçus au la compilation et même au le temps d'exécution.

Typage fort empêche le dessus. Une tentative d'effectuer une opération sur le mauvais type de valeur génère une erreur. Type sécurisé langues fortement typées sont souvent appelées ou sécurité.

Une autre définition de "faiblement typé" se réfère aux langues, tels que Perl , JavaScript et C ++ , ce qui permet un grand nombre de conversions de type implicites. En JavaScript, par exemple, l'expression 2 * x convertit implicitement x à un certain nombre, et cette conversion réussit, même si x est null , undefined , un Array , ou une chaîne de lettres. Ces conversions implicites sont souvent utiles, mais ils peuvent masquer des erreurs de programmation.

Forte et statique sont maintenant généralement considérés comme des concepts orthogonaux, mais l'usage dans la littérature diffère. Certains utilisent le terme fortement typé pour signifier fermement, statiquement typé, ou, encore plus de prêter à confusion, pour signifier tout simplement statiquement typé. Ainsi C a été appelé à la fois fortement typé et faiblement, statiquement typé.

la sémantique d'exécution

Une fois les données a été spécifié, la machine doit être chargé d'effectuer des opérations sur les données. La sémantique d'exécution d'un langage définit comment et quand les différentes constructions d'une langue doivent produire un comportement du programme.

Par exemple, la sémantique peuvent définir le stratégie par laquelle les expressions sont évaluées à des valeurs, ou la manière dont structures de contrôle exécutent conditionnellement déclarations.

Bibliothèque de base

La plupart des langages de programmation ont un associé bibliothèque centrale (parfois connu sous le nom «bibliothèque Standard», en particulier si elle est incluse dans le cadre de la norme linguistique publié), qui est classiquement mis à disposition par toutes les implémentations de la langue. Bibliothèques de base comprennent généralement les définitions pour les algorithmes couramment utilisés, structures de données, et les mécanismes d'entrée et de sortie.

La bibliothèque de base d'une langue est souvent considérée comme faisant partie de la langue par ses utilisateurs, bien que les concepteurs peuvent l'ont traitée comme une entité séparée. De nombreuses spécifications linguistiques définissent un noyau qui doit être mis à disposition dans toutes les implémentations, et dans le cas des langues standardisées cette bibliothèque de base peuvent être nécessaires. La ligne entre une langue et sa bibliothèque de base diffère donc d'une langue à. En effet, certaines langues sont conçus de sorte que les significations de certaines constructions syntaxiques ne peuvent même pas être décrits sans se référer à la bibliothèque centrale. Par exemple, en Java , une chaîne littérale est définie comme une instance de la classe java.lang.String; De même, dans Smalltalk, un anonyme expression de fonction (un «bloc») construit une instance de la classe BlockContext de la bibliothèque. Inversement, Schéma contient plusieurs sous-ensembles cohérents qui suffisent pour construire le reste de la langue comme macros de la bibliothèque, et donc les concepteurs de langage ne même pas la peine de dire quelles parties de la langue doivent être mises en œuvre comme des constructions linguistiques, et qui doit être mis en œuvre en tant que parties d'un bibliothèque.

Pratique

Les concepteurs et les utilisateurs d'une langue doivent construire un certain nombre d'artefacts qui régissent et permettent la pratique de la programmation. Le plus important de ces artefacts sont la description et la mise en oeuvre langue.

Spécification

La spécification d'un langage de programmation est destiné à fournir une définition de la langue utilisateurs et le réalisateurs peuvent utiliser pour déterminer si le comportement d'un programme est correct, compte tenu de son code source.

Une spécification de langage de programmation peut prendre plusieurs formes, dont les suivantes:

• Une définition explicite de la syntaxe, la sémantique statique, et la sémantique d'exécution de la langue. Alors que la syntaxe est généralement spécifié en utilisant une grammaire formelle, définitions sémantiques peuvent être rédigés en langage naturel (par exemple, le langage C ), ou d'un sémantique formelle (par exemple, le Standard ML et Les spécifications de schéma).
• Une description du comportement d'un Traducteur de la langue (par exemple, le C ++ et Spécifications Fortran). La syntaxe et la sémantique de la langue doivent être déduites à partir de cette description, qui peut être écrit dans un langage formel naturel ou un.
• Une référence ou la mise en œuvre du modèle, parfois rédigés dans la langue étant précisé (par exemple, Prolog ou ANSI REXX). La syntaxe et la sémantique de la langue sont explicites dans le comportement de la mise en œuvre de référence.

Exécution

Une mise en œuvre d'un langage de programmation fournit un moyen d'exécuter ce programme sur une ou plusieurs configurations de matériel et de logiciel. Il ya, en gros, deux approches de mise en œuvre du langage de programmation: compilation et interprétation. Il est généralement possible de mettre en oeuvre une langue en utilisant soit la technique.

La sortie d'un compilateur peut être exécuté par le matériel ou un programme appelé un interprète. Dans certaines implémentations qui font usage de l'approche de l'interpréteur il n'y a pas de frontière distincte entre compilation et l'interprétation. Par exemple, certaines implémentations du langage de programmation BASIC compiler puis exécuter la source d'une ligne à la fois.

Les programmes qui sont exécutés directement sur le matériel se exécutent généralement de plusieurs ordres de grandeur plus rapide que ceux qui sont interprétées dans le logiciel.

Une technique pour améliorer la performance des programmes interprétés est Compilation à la volée. Ici, le machine virtuelle, juste avant l'exécution, traduit les blocs de bytecode qui vont être utilisés en code machine pour exécution directe sur le matériel.

Histoire

Une sélection de manuels scolaires qui enseignent la programmation, à la fois dans les langues populaires et obscurs. Ce ne sont que quelques-uns des milliers de langues et dialectes programmation qui ont été conçus dans l'histoire.

Les premiers développements

Les premiers langages de programmation antérieures à l'ordinateur moderne. Le 19ème siècle avait "programmable" métiers à tisser et parchemins joueur de piano qui ont appliqué ce sont aujourd'hui reconnus comme des exemples de langages de programmation spécifiques au domaine. Au début du XXe siècle, des cartes perforées données codées et dirigés traitement mécanique. Dans les années 1930 et 1940, les formalismes de Eglise Alonzo lambda-calcul et Alan Turing s ' machines de Turing fournis abstractions mathématiques pour exprimer des algorithmes ; le calcul de lambda reste influent dans la conception du langage.

Dans les années 1940, les premiers ordinateurs numériques alimentés électriquement ont été créés. La première langage de programmation de haut niveau pour être conçu pour un ordinateur était Plankalkül, développé pour l' allemand Z3 par Konrad Zuse entre 1943 et 1945.

Les ordinateurs du début des années 1950, en particulier le UNIVAC I et la IBM 701 utilisé programmes en langage machine. Première génération de programmation en langage machine a été rapidement remplacé par un seconde génération de langages de programmation connus sous le nom langues de l'Assemblée. Plus tard dans les années 1950, la programmation en langage d'assemblage, qui avait évolué pour inclure l'utilisation de macro-instructions, a été suivie par le développement des trois langues de programmation au niveau supérieur: FORTRAN, LISP, et COBOL. Des versions à jour de tous ceux-ci sont encore en usage général, et chacun a fortement influencé le développement des langues plus tard. A la fin des années 1950, la langue formalisé comme Algol 60 a été introduit, et les langages de programmation les plus tard sont, à bien des égards, les descendants de Algol. Le format et l'utilisation des langages de programmation début a été fortement influencé par le les contraintes de l'interface.

Raffinement

La période des années 1960 à la fin des années 1970 a apporté le développement des grands paradigmes linguistiques actuellement en usage, que de nombreux aspects étaient raffinements d'idées dans la première Troisième génération des langages de programmation:

• APL introduit programmation de type tableau et influencé programmation fonctionnelle.
• PL / I (NPL) a été conçu dans les années 1960 pour intégrer les meilleures idées de FORTRAN et COBOL.
• Dans les années 1960, Simula a été le premier langage conçu pour soutenir programmation orientée objet; Au milieu des années 1970, Smalltalk suivi avec le premier «purement» langage orienté objet.
• C a été développé entre 1969 et 1973 en tant que la programmation des systèmes de la langue, et reste populaire.
• Prolog, conçu en 1972, a été le premier langage de programmation logique.
• En 1978, ML a construit un système de type polymorphe sur le dessus de Lisp, pionnier statiquement typé langages de programmation fonctionnels.

Chacune de ces langues a engendré toute une famille de descendants, et la plupart des langues modernes comptent au moins un d'entre eux dans leur ascendance.

Les années 1960 et 1970 ont également vu un débat considérable sur les mérites de programmation structurée, et si les langages de programmation devraient être conçus pour le soutenir. Edsger Dijkstra, dans une célèbre lettre 1968 publié dans le Communications de l'ACM, ont fait valoir que GOTO devraient être éliminés de tous les langages de programmation "de niveau supérieur".

Les années 1960 et 1970 a également vu l'expansion des techniques qui réduisent l'empreinte d'un programme ainsi que l'amélioration de la productivité du programmeur et utilisateur. Le jeu de cartes pour un début 4GL était beaucoup plus petite pour la même fonctionnalité exprimé dans un Pont 3GL.

Consolidation et la croissance

Les années 1980 ont été des années de consolidation relative. C ++ programmation orientée objet et des systèmes combinés. Le gouvernement des Etats-Unis normalisée Ada, un langage de programmation de systèmes destinés à être utilisés par les entrepreneurs de la défense. Au Japon et ailleurs, des sommes énormes ont été consacré aux enquêtes dite langues "cinquième génération" qui a incorporé constructions de programmation logique. La communauté des langages fonctionnels déménagé à normaliser ML et Lisp. Plutôt que d'inventer de nouveaux paradigmes, tous ces mouvements élaborés sur les idées inventées dans la décennie précédente.

Une tendance importante dans la conception de la langue dans les années 1980 était un accent accru sur la programmation pour les systèmes à grande échelle grâce à l'utilisation de modules ou unités d'organisation à grande échelle de code. Tous les systèmes du module notables développés dans les années 1980 Modula-2, Ada, et ML, bien que d'autres langues, comme PL / I, déjà eu un large soutien pour la programmation modulaire. Systèmes de modules étaient souvent attachés à constructions de programmation génériques.

La croissance rapide de l' Internet au milieu des années 1990 a créé des opportunités pour de nouvelles langues. Perl , à l'origine un outil de script Unix d'abord publié en 1987, est devenu commun en dynamique sites Web. Java est venu à être utilisé pour la programmation côté serveur. Ces développements ne étaient pas fondamentalement roman, plutôt ils étaient raffinements des langues et des paradigmes existants, et en grande partie basée sur la famille C des langages de programmation.

l'évolution du langage de programmation continue, tant dans l'industrie et la recherche. Les orientations actuelles sont la sécurité et la vérification de la fiabilité, de nouveaux types de modularité ( mixins, délégués, aspects), et l'intégration de bases de données.

Le L4G sont des exemples de langues qui sont spécifiques à un domaine, comme SQL, qui manipule et retours ensembles de données plutôt que les valeurs scalaires qui sont canonique à la plupart des langages de programmation. Perl , par exemple, avec son ' ici document «peut contenir plusieurs programmes 4GL, ainsi que les programmes JavaScript multiples, dans le cadre de son propre code de perl et utiliser l'interpolation de variables dans le 'document en' pour soutenir la programmation multi-langue.

usage de la langue de mesure

Il est difficile de déterminer quels sont les langages de programmation les plus largement utilisés, et quels moyens l'utilisation varie selon le contexte. Une langue peut occuper le plus grand nombre d'heures de programmeur, un autre ont plus de lignes de code, et un tiers utilisent le plus de temps processeur. Certaines langues sont très populaires pour des types particuliers d'applications. Par exemple, COBOL est toujours forte dans le centre de données d'entreprise, souvent sur de grandes mainframes; FORTRAN dans les applications d'ingénierie; C dans les applications embarquées et de systèmes d'exploitation; et d'autres langues sont régulièrement utilisés pour écrire de nombreux types d'applications.

Différentes méthodes de mesure de la popularité de la langue, chacun étant soumis à une polarisation différente sur ce qui est mesuré, ont été proposées:

• compter le nombre des offres d'emploi qui mentionnent la langue
• le nombre de livres vendus qui enseignent ou décrivent la langue
• les estimations du nombre de lignes existantes de code écrit dans la langue-qui peut sous-estimer les langues ne trouve pas souvent dans les recherches publiques
• chiffres de références linguistiques trouvés en utilisant un moteur de recherche web.

Taxonomies

Il ne existe aucun régime de classification global pour les langages de programmation. Un langage de programmation donnée n'a généralement pas une langue ancêtre unique. Langues surviennent souvent en combinant les éléments de plusieurs langues remplacées avec de nouvelles idées en circulation à l'époque. Idées qui proviennent dans une langue se répandra dans une famille de langues apparentées, puis bondir soudainement à travers lacunes familiales à apparaître dans une famille tout à fait différente.

La tâche est encore compliquée par le fait que les langues peuvent être classés long de plusieurs axes. Par exemple, Java est à la fois un langage orienté objet (car il encourage orienté objet organisation) et une langue concurrente (car il contient des constructions intégrées pour l'exécution de plusieurs threads en parallèle). Python est un orientée objet langage de script.

Dans les grandes lignes, les langages de programmation se divisent en programmation paradigmes et un classement par domaine d'utilisation prévue. Paradigmes comprennent la programmation procédurale, la programmation orientée objet, programmation fonctionnelle, et programmation logique; certaines langues sont des hybrides de paradigmes ou multi-paradigmatique. Une langage d'assemblage ne est pas tant un paradigme de modèle direct d'une architecture de la machine sous-jacente. En effet, les langages de programmation peuvent être considérées comme objectif général, des langages de programmation du système, les langages de script, langues spécifiques à un domaine, ou langages concurrents / distribués (ou une combinaison de ceux-ci). Certaines langues d'usage général ont été conçus en grande partie avec des objectifs éducatifs.

Un langage de programmation peut aussi être classé par des facteurs non liés au paradigme de programmation. Par exemple, la plupart des langages de programmation utilisent langue anglaise des mots-clés, tandis qu'un minorité ne le font pas. D'autres langues peuvent être classés comme étant ésotérique ou non.