Interpreted language

related topics
{math, number, function}
{language, word, form}
{system, computer, user}

In computer programming, an interpreted language is a programming language in which programs are 'indirectly' executed ("interpreted") by an interpreter program. This can be contrasted with a compiled language which is converted into machine code and then 'directly' executed by the host CPU. Theoretically, any language may be compiled or interpreted, so this designation is applied purely because of common implementation practice and not some essential property of a language. Indeed, for some programming languages, there is little performance difference between an interpretive- or compiled-based approach to their implementation.

Many languages have been implemented using both compilers and interpreters, including Lisp, Pascal, C, BASIC, and Python. While Java is translated to a form that is intended to be interpreted, just-in-time compilation is often used to generate machine code. The Microsoft .NET languages compile to Common Intermediate Language (CIL) which is often then compiled into native machine code; however there is a virtual machine able to interpret CIL. Many Lisp implementations can freely mix interpreted and compiled code. These implementations also use a compiler that can translate arbitrary source code at runtime to machine code.

Contents

Historical background of interpreted/compiled

In the early days of computing, language design was heavily influenced by the decision to use compiling or interpreting as a mode of execution. For example, some compiled languages require that programs must explicitly state the data-type of a variable at the time it is declared or first used while some interpreted languages take advantage of the dynamic aspects of interpreting to make such declarations unnecessary. For example, Smalltalk (1980), which was designed to be interpreted at run-time, allows generic objects to dynamically interact with each other.

Initially, interpreted languages were compiled line-by-line; that is, each line was compiled as it was about to be executed, and if a loop or subroutine caused certain lines to be executed multiple times, they would be recompiled every time. This has become much less common. Most so-called interpreted languages use an intermediate representation, which combines compiling and interpreting. In this case, a compiler may output some form of bytecode or threaded code, which is then executed by a bytecode interpreter. Examples include:

Full article ▸

related documents
Sather
Catalan's conjecture
Constant term
Symmetric tensor
Linear prediction
Commutative diagram
Matrix addition
Atlas (topology)
Infinite set
BQP
Most significant bit
Cauchy's integral theorem
Canonical LR parser
Dirichlet's theorem on arithmetic progressions
Condition number
Finitely generated abelian group
Merge algorithm
Wreath product
NC (complexity)
Nilpotent group
Vector calculus
EXPTIME
Single precision
Linear span
Hilbert's basis theorem
Addition of natural numbers
Unification
Exponential time
Axiom of extensionality
Directed set