High-level programming language

(computer science) A computer language whose instructions or statements each correspond to several machine language instructions, designed to make coding easier. Also known as higher-level language; higher-order language.

The first large computers, such as the ENIAC, incorporated logic that was part of the circuitry; therefore, they could only be "programmed" to a small extent by changing wiring. These were followed by programmable computers with von Neumann architecture. Instructions were independent of the circuitry. Early programs were entirely written in machine language; that is, each instruction gave the central processing unit (CPU) a specific task to do, typically one such as "move a word from one specified location to another" or "change a bit in a specified location from a 0 to a 1 unless 1 already." During the 1940s and the early 1950s, all computers were programmed in this kind of machine code. Such programming was a difficult and tedious task, requiring good knowledge of how the hardware of a computer works.

The introduction of interpreters was a major breakthrough. Interpreters translate a program written in an easier programming language into machine language. Particular locations in the CPU did not have to be specified, and commands were more closely connected to operations. A big disadvantage of such an interpreter is that it translates the program line by line into machine language, slowing down execution.

A compiler offers a better method for translating programming language into machine language. A compiler translates a whole program into machine language first. When the compiled program is run on the computer, execution time is shortened since there is no translation step going on. Grace Murray Hopper developed one of the first such compilers during the early 1950s.

During World War II, Hopper had been working with Howard Aiken at the Bureau of Ordnance Computation Project at Harvard. Aiken had built the Mark I computer, a huge electromechanical calculator. Hopper designed programs for that computer so that it performed complex calculations for the military. In 1945 she and the team at Harvard started developing Mark II. It was in this computer that a moth, in the words of Hopper, "had been beaten to death" by a relay, stopping the computer. The moth ended up Scotch-taped in their lab logbook, with the note "First actual case of bug being found." Even then the word bug denoted something that caused the computer to fail or to produce incorrect calculations.

Hopper created the first compiler for UNIVAC. Hopper's compiler turned programs written in simple English into machine code. Saying that she was going to communicate with a computer in plain English produced general disbelief. Managers had accepted that computers understand numbers; but computers that understand English seemed inconceivable. Although it made the work of programmers much easier, convincing them to use the compiler was not an easy task. They had gotten used to writing machine code. Hopper developed distaste for the phrase "but we've always done it that way."

During the 1950s several experimental and mostly mathematically oriented languages appeared. The first one that gathered wide success was FORTRAN (FORmula TRANslator). Developed in 1956, it underwent several changes and is still used today in technical and scientific applications.

Several other languages with different orientations appeared. One of them, COBOL, was developed in 1959 by Grace Hopper for business applications. BASIC, a programming language developed by the mathematicians John Kemeny and Thomas Kurtz at Dartmouth University in 1965, was first used as an educational tool, but became in the late 1970s the most popular language for the personal computer.

BASIC, and to a lesser degree FORTRAN, was often criticized because of the use of loops and branches. These produced the inconvenience that when a program grew to any length, it became more and more entangled, a phenomenon called spaghetti. A minor change anywhere in the program could have uncontrollable repercussions in the whole program, requiring tedious searches and rewriting, a process called debugging.

Languages that allow structured programming were a solution to the spaghetti problem. ALGOL, developed by an international committee, and Pascal, written by Niklaus Wirth, are such languages. These languages require that the coding be organized in logical groups, making reading and amending programs much easier.

In these languages, the software itself and the data are entirely separated. In a more recent approach, data and logical procedures are grouped into discrete units called objects. The first of these object-oriented languages was Simula I, developed in 1965. Its successors, Simula languages designed for various specific computers, introduced the concepts of "object" and "class," in which classes are objects that have similar properties. Groups of objects, or classes, can be related by inheriting characteristics from one group to its successors. SMALLTALK, which used many of the ideas behind Simula, introduced communication between objects; a later version of SMALLTALK incorporated the concept of inheritance. These concepts, which became well known with the advent of object-oriented languages, had been invented early in the 20th century by mathematicians who could not have foreseen their eventual application to computers.

Object orientation has been termed a revolution in software development. Because objects can be used independently in software development, they can also be reused as building blocks, allowing much faster development of software systems. Several other object-oriented languages have been written; among the better-known are C++, Eiffel, Object Pascal, and Clascal.

JAVA, introduced by Sun Microsystems in 1995, takes a different approach. It is designed so that programmers write an application once and the program runs on any computer platform, including Windows, Macintosh, and Linux. Although Microsoft tried to modify a version of JAVA to be specific to their Windows operational system, this was overturned by Sun as part of a lawsuit against the Microsoft monopoly in personal computers operating systems.

The noun has one meaning:

Meaning #1: a problem-oriented language requiring little knowledge of the computer on which it will be run

This article is in need of attention from an expert on the subject. WikiProject Computer science or the Computer science Portal may be able to help recruit one. (November 2008)

In computing, 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 be more portable across platforms. Such languages hide the details of CPU operations such as memory access models and management of scope.

This greater abstraction and hiding of details is generally intended to make the language user-friendly, as it includes concepts from the problem domain instead of those of the machine used. A high-level language isolates the execution semantics of a computer architecture from the specification of the program, making the process of developing a program simpler and more understandable with respect to a low-level language. The amount of abstraction provided defines how "high-level" a programming language is.^[1]

The first high-level programming language to be designed for a computer was Plankalkül, created by Konrad Zuse. However, it was not implemented in his time and his original contributions were isolated from other developments.

Contents 1 Features 1.1 Abstraction penalty 2 Relative meaning 3 Execution models 4 See also 5 External links 6 References

Features

The term "high-level language" does not imply that the language is 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, threads, locks, objects, 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.

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 ^[2][3][4]. 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 code comparable in efficiency to what most low-level programmers can produce by hand^{[citation needed]}, and the higher abstraction may allow for more powerful techniques providing better overall results than their low-level counterparts in particular settings.^[5]

Relative meaning

The terms high-level and low-level are inherently relative. Some decades ago, the C language, and similar languages, was 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". Many programmers today might refer to C as low-level, as it lacks a large runtime-system (no garbage collection etc), 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.

Also note that assembly language may itself be regarded as a higher level (but often still one-to-one if used without macros) representation of machine code, as it supports concepts such as constants and (limited) 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. See C2's page about high-level languages.

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.

See also

• Abstraction (computer science)
• Generational list of programming languages
• Low-level programming languages
• Very high-level programming languages
• Categorical list of programming languages

External links

• http://c2.com/cgi/wiki?HighLevelLanguage - The WikiWikiWeb's article on high-level programming languages

References

1. ^ HThreads - RD Glossary
2. ^ Surana P (2006) (PDF). Meta-Compilation of Language Abstractions.. ftp://lispnyc.org/meeting-assets/2007-02-13_pinku/SuranaThesis.pdf. Retrieved 2008-03-17. 
3. ^ Kuketayev. "The Data Abstraction Penalty (DAP) Benchmark for Small Objects in Java.". http://www.adtmag.com/joop/article.aspx?id=4597. Retrieved 2008-03-17. 
4. ^ 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 
5. ^ Manuel Carro, José F. Morales, Henk L. Muller, G. Puebla, M. Hermenegildo (2006), "High-level languages for small devices: a case study" (PDF), Proceedings of the 2006 international conference on Compilers, architecture and synthesis for embedded systems, ACM, http://www.clip.dia.fi.upm.es/papers/carro06:stream_interpreter_cases.pdf 

v • d • e Types of programming languages Array · Aspect-oriented · Assembly · Class-based · Compiled · Concurrent · Curly bracket · Data-oriented · Data-structured · Dataflow · Declarative · Domain-specific · Dynamic · Esoteric · Event-driven · Extensible · Functional · High-level · Imperative · Interpreted · Logic · Low-level · Machine · Macro · Metaprogramming · Multi-paradigm · Non-English-based · Object-oriented · Off-side rule · Pipeline · Procedural · Prototype-based · Reflective · Rule-based · Scripting · Synchronous · Visual

This entry is from Wikipedia, the leading user-contributed encyclopedia. It may not have been reviewed by professional editors (see full disclaimer)