Gourt Home::Gourt :: Interpreted language
In computer programming, an interpreted language is a programming language whose programs may be executed from source form, by an interpreter. Any language may, in theory, be compiled or interpreted; therefore, this designation refers to languages' implementations rather than designs. In fact, many languages have both compilers and interpreters, including Lisp, C, BASIC, and Python. New implementations of Java and C Sharp use just-in-time compilation, while the runtime virtual machines are usually interpreters.
Interpreters are generally slower to run, but more flexible than compilers. LISP manages dynamic lists, while most BASIC interpreters managed dynamically allocated strings. Interpreters usually skip a linking and compilation step, enabling faster turn-around and decreasing cost of programmer time, and tend to be favored in Rapid Application Development environments. This also made it ideal for disk-less environments such as the first personal computers, since a compiler usually needs a disk drive to store the object modules, and link them into an executable. The popularity of Microsoft BASIC led to the largest software company in history.
This term is often one of the first terms covered in computer science, although most languages can be implemented as either compilers or interpreters. People often use it to signify languages that are traditionally interpreted, or for which no compilers are written.
Historical background
In the early days of computing, language design was heavily influenced by the decision to use compilation or interpretation 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. On the other hand, some languages take advantage of the dynamic aspects of interpretation to make such declarations unnecessary. For example, Smalltalk—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 both compilation and interpretation. In this case, a compiler may output some form of bytecode, which is then executed by a bytecode interpreter. Examples include Python, Java, and Perl. Similarly, Ruby uses an abstract syntax tree as intermediate representation. The intermediate representation can be compiled once and for all, like Java, each time before execution like Perl or Ruby, or each time a change in the source is detected before execution like Python.
Language features suiting interpreters well
Interpreted languages still give programs certain extra flexibility over compiled languages. Features that are easier to implement in interpreters than in compilers include (but are not limited to):
- platform independence (Java's byte code, for example)
- reflective usage of the evaluator (e.g. a first-order eval function)
- dynamic typing
- ease of debugging (It is easier to get source code information in interpreted language)
- small program size (Since interpreted languages have flexibility to choose instruction code)
- object polymorphism
- dynamic scoping
List of frequently interpreted languages
- APL A vector oriented language using an incomprehensible character set.
- ASP Web page scripting language
- BASIC (although the original version, Dartmouth BASIC, was compiled, as are most modern BASICs)
- Ch (embeddable C/C++ interpreter)
- CINT (C/C++ interpreter)
- Euphoria Interpreted or compiled.
- Excel Microsoft Excel stores formulas and interprets them from a tokenized format.
- Forth (traditionally threaded interpreted)
- HTML Web text and graphics presentation language
- Java (compiled to bytecode which is then interpreted)
- JavaScript Embedded in HTML pages.
- Lisp (Sometimes interpreted, sometimes compiled to bytecode or native machine code)
- Logo (interpretation makes interactivity easier)
- Maple
- MATLAB
- MUMPS (traditionally interpreted, modern versions compiled)
- Perl (compiled to bytecode which is then interpreted)
- PHP Compiled to bytecode.
- Pike (compiled to bytecode which is then interpreted)
- Python (compiled to bytecode which is then interpreted)
- Ruby
- Tcl
- Various scripting languages Interpreted or compiled.
- Smalltalk Object oriented language often supports debugging across machines.
See also
"Interpreted language"