High-level programming language

From Wikipedia, the free encyclopedia

A high-level programming language is a programming language that, in comparison to low-level programming languages, may be English-like, more abstract, easier to use, or more portable across platforms. Such languages often abstract away CPU operations such as memory access models and management of scope.

Contents

[edit] Historical Note

The first high-level programming language was the "Plankalkül", invented by Konrad Zuse.

[edit] Features

The term "high-level language" does not imply that the language is always superior to low-level programming languages - in fact, in terms of the depth of knowledge of how computers work required to productively program in a given language, the inverse may be true. Rather, "high-level language" refers to the higher level of abstraction from machine language. Rather than dealing with registers, memory addresses and call stacks, high-level languages deal with usability, variables, arrays and complex arithmetic or boolean expressions. In addition, they have no opcodes that can directly compile the language into machine code, unlike low-level assembly language. Other features such as string handling routines, object-oriented language features and file input/output may also be present.

[edit] Abstraction penalty

Stereotypically, high-level languages make complex programming simpler, while low-level languages tend to produce more efficient code. Abstraction penalty is the barrier preventing applying high level programming techniques in situations where computational resources are limited. High level programming features like more generic data structures, run-time interpretation and intermediate code files often result in slower execution speed, higher memory consumption and larger binary size [1][2][3]. For this reason, code which needs to run particularly quickly and efficiently may be written in a lower-level language, even if a higher-level language would make the coding easier.

However, with the growing complexity of modern microprocessor architectures, well-designed compilers for high-level languages frequently produce more efficient code than most low-level programmers can produce by hand.[citation needed]

[edit] Relative meaning

The terms "high-level" and "low-level" are inherently relative. Originally, assembly language was considered low-level and COBOL, C, etc. were considered high-level, as they allowed the abstractions of functions, variables and expression evaluation. Many programmers today might refer to C as low-level, as it still allows memory to be accessed by address, and provides direct access to the assembly level. For more on this distinction, see C2's page about high-level languages.

[edit] Execution models

There are three models of execution for modern high-level languages:

Interpreted 
Interpreted languages are read and then executed directly, with no compilation stage.
Compiled 
Compiled languages are transformed into an executable form before running. There are two types of compilation:
Intermediate representations 
When a language is compiled to an intermediate representation, that representation can be optimized or saved for later execution without the need to re-read the source file. When the intermediate representation is saved it is often represented as bytecode.
Machine code generation 
Some compilers compile source code directly into machine code. Virtual machines that execute bytecode directly or transform it further into machine code have blurred the once clear distinction between intermediate representations and truly compiled languages.
Translated 
A language may be translated into a low-level programming language for which native code compilers are already widely available. The C programming language is a common target for such translators.

[edit] See also

[edit] External links

[edit] References

  1. ^ Surana P (2006). "Meta-Compilation of Language Abstractions." (PDF). Retrieved on 2008-03-17.
  2. ^ Kuketayev. The Data Abstraction Penalty (DAP) Benchmark for Small Objects in Java.. Retrieved on 2008-03-17.
  3. ^ Chatzigeorgiou & Stephanides (2002), “Evaluating Performance and Power Of Object-Oriented Vs. Procedural Programming Languages”, in Blieberger & Strohmeier, Proceedings - 7th International Conference on Reliable Software Technologies - Ada-Europe'2002, Springer, pp. 367, <http://books.google.com/books?id=QMalP1P2kAMC&dq=%22abstraction+penalty%22&lr=&source=gbs_summary_s&cad=0>