High-level programming language

In computer science, a high-level programming
language is a programming language with strong abstraction from the details of the computer. In comparison to low-level programming languages,
it may use natural language elements, be easier to use, or may automate significant areas
of computing systems, making the process of developing a program simpler and more understandable
relative to a lower-level language. The amount of abstraction provided defines
how “high-level” a programming language is. In the 1960s, high-level programming languages
using a compiler were commonly called autocodes. Examples of autocodes are COBOL and Fortran. The first high-level programming language
designed for computers was Plankalkül, created by Konrad Zuse. However, it was not implemented in his time,
and his original contributions were largely isolated from other developments, although
it influenced Heinz Rutishauser’s language “Superplan”. The first really widespread high-level language
was Fortran, a machine independent development of IBM’s earlier Autocode systems. Algol, defined in 1958 and 1960, by committees
of European and American computer scientist, introduced recursion as well as nested functions
under lexical scope. It was also the first language with a clear
distinction between value and name-parameters and their corresponding semantics. Algol also introduced several structured programming
concepts, such as the while-do and if-then-else constructs and its syntax was the first to
be described by a formal method, called BNF, for Backus-Naur form. During roughly the same period Cobol introduced
records and Lisp introduced a fully general lambda abstraction in a programming language
for the first time. Examples of popular high-level programming
languages today may include Java, Python, Visual Basic, Delphi, Perl, PHP, ECMA Script,
Ruby and many others. Features
“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 variables, arrays, objects, complex
arithmetic or boolean expressions, subroutines and functions, loops, threads, locks, and
other abstract computer science concepts, with a focus on usability over optimal program
efficiency. Unlike low-level assembly languages, high-level
languages have few, if any, language elements that translate directly into a machine’s native
opcodes. Other features, such as string handling routines,
object-oriented language features, and file input/output, may also be present. Abstraction penalty
While high-level languages are intended to make complex programming simpler, low-level
languages often produce more efficient code. Abstraction penalty is the border that prevents
high-level programming techniques from being applied in situations where computational
resources are limited. High-level programming exhibits features like
more generic data structures, run-time interpretation, and intermediate code files; which often result
in slower execution speed, higher memory consumption, and larger binary program size. For this reason, code which needs to run particularly
quickly and efficiently may require the use of a lower-level language, even if a higher-level
language would make the coding easier. In many cases, critical portions of a program
mostly in a high-level language can be hand-coded in assembly language, leading to a much faster
or more efficient optimised program. However, with the growing complexity of modern
microprocessor architectures, well-designed compilers for high-level languages frequently
produce code comparable in efficiency to what most low-level programmers can produce by
hand, and the higher abstraction may allow for more powerful techniques providing better
overall results than their low-level counterparts in particular settings. High-level languages are designed independent
of structure of a specific computer. This facilitates executing a program written
in such a language on different computers. Relative meaning
The terms high-level and low-level are inherently relative. Some decades ago, the C language, and similar
languages, were most often considered “high-level”, as it supported concepts such as expression
evaluation, parameterised recursive functions, and data types and structures, while assembly
language was considered “low-level”. Today, many programmers might refer to C as
low-level, as it lacks a large runtime-system, basically supports only scalar operations,
and provides direct memory addressing. It, therefore, readily blends with assembly
language and the machine level of CPUs and microcontrollers. Assembly language may itself be regarded as
a higher level representation of machine code, as it supports concepts such as constants
and expressions, sometimes even variables, procedures, and data structures. Machine code, in its turn, is inherently at
a slightly higher level than the microcode or micro-operations used internally in many
processors. Execution models
There are three general models of execution for modern high-level languages:
Interpreted Interpreted languages are read and then executed
directly, with no compilation stage. A program called an interpreter reads each
program statement following the program flow, decides what to do, and does it. A hybrid of an interpreter and a compiler
will compile the statement into machine code and execute that; the machine code is then
discarded, to be interpreted anew if the line is executed again. Interpreters are commonly the simplest implementations,
compared to the other two variants listed here. Compiled
Compiled languages are transformed into an executable form before running. There are two types of compilation:
Machine code generation Some compilers compile source code directly
into machine code. This is the original mode of compilation,
and languages that are directly and completely transformed to machine-native code in this
way may be called “truly compiled” languages. See assembly language. 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 byte code. The intermediate representation must then
be interpreted or further compiled to execute it. Virtual machines that execute byte code directly
or transform it further into machine code have blurred the once clear distinction between
intermediate representations and truly compiled languages. Translated or Trans-compiled
A language may be translated into a lower-level programming language for which native code
compilers are already widely available. The C programming language is a common target
for such translators. See Chicken Scheme and the Eiffel as examples. Specifically, the generated C and C++ code
can be seen in the EIFGENs directory of any compiled Eiffel project. In Eiffel, the “Translated” process is referred
to as Trans-compiling or Trans-compiled, and the Eiffel compiler as a Transcompiler. Note that languages are not strictly “interpreted”
languages or “compiled” languages. Rather, language implementations use interpretation
or compilation. For example, Algol 60 and Fortran have both
been interpreted. Similarly, Java shows the difficulty of trying
to apply these labels to languages, rather than to implementations; Java is compiled
to bytecode and the bytecode is subsequently executed by either interpretation or compilation. Moreover, compilation, trans-compiling, and
interpretation are not strictly limited just a description of the compiler artifact. The Eiffel programming language uses both
forms of compilation in a single development system. While “Finalized” Eiffel code is trans-compiled
to binary, “code-in-development” exists partially as either fully compiled machine code or as
intermediate byte code, being interpreted by an Eiffel run-time. Thus, for purposes of efficient development,
the majority of an Eiffel project is compiled to binary, with small code changes “melted”
out of the binary into IL “byte-code” in an Eiffel run-time virtual machine. As development moves along, the programmer
will periodically “freeze” the small “melted” portions of code back into the “workbench”
binary. See also Abstraction
Generational list of programming languages Low-level programming languages
Very high-level programming languages Categorical list of programming languages References External links
http:c2.comwiki?HighLevelLanguage – The WikiWikiWeb’s article on high-level programming languages