Langage de programmation de haut niveau - High-level programming language

En informatique , un langage de programmation de haut niveau est un langage de programmation avec une forte abstraction des détails de l' ordinateur . Contrairement aux langages de programmation de bas niveau , il peut utiliser des éléments de langage naturel , être plus facile à utiliser ou peut automatiser (ou même masquer entièrement) des zones importantes des systèmes informatiques (par exemple la gestion de la mémoire ), rendant le processus de développement d'un programme plus simple et plus compréhensible qu'en utilisant un langage de niveau inférieur. La quantité d'abstraction fournie définit à quel point un langage de programmation est « de haut niveau ».

Dans les années 1960, les langages de programmation de haut niveau utilisant un compilateur étaient communément appelés autocodes . Des exemples d'autocodes sont COBOL et Fortran .

Le premier langage de programmation de haut niveau conçu pour les ordinateurs était Plankalkül , créé par Konrad Zuse . Cependant, il n'a pas été mis en œuvre à son époque et ses contributions originales ont été largement isolées des autres développements dus à la Seconde Guerre mondiale , à part l'influence de la langue sur la langue "Superplan" de Heinz Rutishauser et aussi dans une certaine mesure Algol . Le premier langage de haut niveau largement répandu était Fortran , un développement indépendant de la machine des premiers systèmes Autocode d'IBM . La Algol famille, avec Algol 58 défini en 1958 et Algol 60 défini en 1960 par des comités de scientifiques européens et informatiques américains, a présenté récursion ainsi que les fonctions imbriquées dans la portée lexicale . Algol 60 était également le premier langage avec une distinction claire entre les paramètres de valeur et de nom et leur sémantique correspondante . Algol a également introduit plusieurs concepts de programmation structurés , tels que les constructions while-do et if-then-else et sa syntaxe a été la première à être décrite en notation formelle - " Backus-Naur form " (BNF). Pendant à peu près la même période, Cobol a introduit des enregistrements (également appelés structs) et Lisp a introduit pour la première fois une abstraction lambda entièrement générale dans un langage de programmation.

Caractéristiques

« Langage de haut niveau » fait référence au niveau d'abstraction le plus élevé du langage machine . Plutôt que de traiter des registres, des adresses mémoire et des piles d'appels, les langages de haut niveau traitent des variables, des tableaux, des objets , des expressions arithmétiques ou booléennes complexes, des sous-routines et des fonctions, des boucles, des threads , des verrous et d'autres concepts informatiques abstraits, avec un se concentrer sur la convivialité plutôt que sur l'efficacité optimale du programme. Contrairement aux langages d'assemblage de bas niveau , les langages de haut niveau ont peu ou pas d'éléments de langage qui se traduisent directement dans les opcodes natifs d'une machine . D'autres fonctionnalités, telles que des routines de gestion de chaînes, des fonctionnalités de langage orienté objet et des entrées/sorties de fichiers, peuvent également être présentes. Une chose à noter à propos des langages de programmation de haut niveau est que ces langages permettent au programmeur d'être détaché et séparé de la machine. Autrement dit, contrairement aux langages de bas niveau comme l'assembleur ou le langage machine, la programmation de haut niveau peut amplifier les instructions du programmeur et déclencher de nombreux mouvements de données en arrière-plan à son insu. La responsabilité et le pouvoir d'exécution des instructions ont été transférés à la machine par le programmeur.

Pénalité d'abstraction

Les langages de haut niveau visent à fournir des fonctionnalités qui normalisent les tâches courantes, permettent un débogage riche et maintiennent l'agnosticisme architectural ; tandis que les langages de bas niveau produisent souvent un code plus efficace grâce à l' optimisation d'une architecture système spécifique. La pénalité d'abstraction est le coût que les techniques de programmation de haut niveau paient pour ne pas être en mesure d'optimiser les performances ou d'utiliser certains matériels car elles ne tirent pas parti de certaines ressources architecturales de bas niveau. La programmation de haut niveau présente des fonctionnalités telles que des structures de données et des opérations plus génériques, une interprétation à l'exécution et des fichiers de code intermédiaires ; qui entraînent souvent l'exécution de beaucoup plus d'opérations que nécessaire, une consommation de mémoire plus élevée et une plus grande taille de programme binaire. Pour cette raison, un code qui doit s'exécuter particulièrement rapidement et efficacement peut nécessiter l'utilisation d'un langage de niveau inférieur, même si un langage de niveau supérieur faciliterait le codage. Dans de nombreux cas, les parties critiques d'un programme, principalement dans un langage de haut niveau, peuvent être codées à la main en langage assembleur , ce qui permet d'obtenir un programme optimisé beaucoup plus rapide, plus efficace ou tout simplement fiable .

Cependant, avec la complexité croissante des architectures de microprocesseurs modernes , des compilateurs bien conçus pour les langages de haut niveau produisent fréquemment un code comparable en efficacité à ce que la plupart des programmeurs de bas niveau peuvent produire à la main, et l'abstraction plus élevée peut permettre des techniques plus puissantes offrant une meilleure résultats globaux que leurs homologues de bas niveau dans des contextes particuliers. Les langages de haut niveau sont conçus indépendamment d'une architecture de système informatique spécifique. Cela facilite l'exécution d'un programme écrit dans un tel langage sur n'importe quel système informatique avec un support compatible pour le programme interprété ou JIT . Les langages de haut niveau peuvent être améliorés au fur et à mesure que leurs concepteurs développent des améliorations. Dans d'autres cas, de nouveaux langages de haut niveau évoluent à partir d'un ou plusieurs autres dans le but d'agréger les constructions les plus populaires avec des fonctionnalités nouvelles ou améliorées. Un exemple de ceci est Scala qui maintient une compatibilité descendante avec Java, ce qui signifie que les programmes et bibliothèques écrits en Java continueront d'être utilisables même si un magasin de programmation passe à Scala ; cela rend la transition plus facile et la durée de vie d'un tel codage de haut niveau indéfinie. En revanche, les programmes de bas niveau survivent rarement au-delà de l'architecture système pour laquelle ils ont été écrits sans révision majeure. C'est le "compromis" d'ingénierie pour la "pénalité d'abstraction".

Sens relatif

Des exemples de langages de programmation de haut niveau actuellement utilisés sont Python , Visual Basic , Delphi , Perl , PHP , ECMAScript , Ruby , C# , Java et bien d'autres.

Les termes de haut niveau et de bas niveau sont intrinsèquement relatifs. Il y a quelques décennies, le langage C et les langages similaires étaient le plus souvent considérés comme « de haut niveau », car il prenait en charge des concepts tels que l'évaluation d'expressions, les fonctions récursives paramétrées et les types et structures de données, tandis que le langage d'assemblage était considéré comme « de bas niveau ". Aujourd'hui, de nombreux programmeurs peuvent qualifier le C de bas niveau, car il manque d'un grand système d' exécution (pas de récupération de place, etc.), ne prend en charge que les opérations scalaires et fournit un adressage mémoire direct. Il se mélange donc facilement avec le langage assembleur et le niveau machine des processeurs et des microcontrôleurs .

Le langage d'assemblage peut lui-même être considéré comme une représentation de niveau supérieur (mais toujours un à un s'il est utilisé sans macros ) du code machine , car il prend en charge des concepts tels que des constantes et des expressions (limitées), parfois même des variables, des procédures et des données. structure . Le code machine , à son tour, est intrinsèquement à un niveau légèrement supérieur au microcode ou aux micro-opérations utilisées en interne dans de nombreux processeurs.

Modes d'exécution

Il existe trois modes généraux d'exécution pour les langages modernes de haut niveau :

Interprété
Lorsqu'un code écrit dans un langage est interprété , sa syntaxe est lue puis exécutée directement, sans étape de compilation. Un programme appelé interpréteur lit chaque instruction de programme, en suivant le déroulement du programme, puis décide quoi faire et le fait. Un hybride d'un interpréteur et d'un compilateur compilera l'instruction en code machine et l'exécutera ; le code machine est alors rejeté, pour être interprété à nouveau si la ligne est à nouveau exécutée. Les interprètes sont généralement les implémentations les plus simples du comportement d'un langage, par rapport aux deux autres variantes répertoriées ici.
Compilé
Lorsque du code écrit dans un langage est compilé , sa syntaxe est transformée en une forme exécutable avant de s'exécuter. Il existe deux types de compilation :
Génération de code machine
Certains compilateurs compilent le code source directement en code machine . C'est le mode de compilation original, et les langages qui sont directement et complètement transformés en code natif de la machine de cette manière peuvent être appelés langages véritablement compilés . Voir langage assembleur .
Représentations intermédiaires
Lorsque le code écrit dans un langage est compilé en une représentation intermédiaire , cette représentation peut être optimisée ou enregistrée pour une exécution ultérieure sans qu'il soit nécessaire de relire le fichier source. Lorsque la représentation intermédiaire est enregistrée, elle peut être sous une forme telle que bytecode . La représentation intermédiaire doit ensuite être interprétée ou encore compilée pour l'exécuter. Les machines virtuelles qui exécutent le bytecode directement ou le transforment davantage en code machine ont brouillé la distinction autrefois claire entre les représentations intermédiaires et les langages véritablement compilés.
Source à source traduit ou transcompilé
Le code écrit dans un langage peut être traduit en termes d'un langage de niveau inférieur pour lequel les compilateurs de code natif sont déjà courants. JavaScript et le langage C sont des cibles communes pour de tels traducteurs. Voir CoffeeScript , Chicken Scheme et Eiffel comme exemples. Plus précisément, le code C et C++ généré peut être vu (comme généré à partir du langage Eiffel lors de l'utilisation de l' IDE EiffelStudio ) dans le répertoire EIFGENs de tout projet Eiffel compilé. Dans Eiffel, le processus traduit est appelé transcompilation ou transcompilation, et le compilateur Eiffel est appelé transcompilateur ou compilateur source à source .

Notez que les langues ne sont pas des langues strictement interprétées ou des langues compilées . Les implémentations du comportement linguistique utilisent plutôt l'interprétation ou la compilation. Par exemple, ALGOL 60 et Fortran ont tous deux été interprétés (même s'ils étaient plus généralement compilés). De même, Java montre la difficulté d'essayer d'appliquer ces étiquettes aux langages plutôt qu'aux implémentations ; Java est compilé en bytecode qui est ensuite exécuté soit par interprétation (dans une machine virtuelle Java (JVM)) soit par compilation (généralement avec un compilateur juste à temps tel que HotSpot , toujours dans une JVM). De plus, la compilation, la transcompilation et l'interprétation ne se limitent pas strictement à une description de l'artefact du compilateur (exécutable binaire ou assembly IL).

Architecture informatique en langage de haut niveau

Alternativement, il est possible qu'un langage de haut niveau soit directement implémenté par un ordinateur - l'ordinateur exécute directement le code HLL. C'est ce qu'on appelle une architecture informatique de langage de haut niveau - l' architecture informatique elle-même est conçue pour être ciblée par un langage de haut niveau spécifique. Les grands systèmes de Burroughs étaient des machines cibles pour ALGOL 60 , par exemple.

Voir également

Remarques

Les références

Liens externes