Home > Interpreted language

This term has no meaning in computer science, which strictly distinguishes between languages and implementations. However, people often use it as a useful shortcut to signify languages that are traditionally interpreted, or for which no compilers are written.

1 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.

2 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)
• dynamic evaluation of code (e.g. eval function)
• ease of debuggingDebugging is a methodical process of finding and reducing the number of bugs in a computer program and/or a piece of electronic hardware to make it work better, or at all. The more/untidier connections there exist between various subsystems, the harder th (It is easier to get source code information in interpreted language)
• small program size (Since interpreted languages have flexibility to choose instruction code)
• object polymorphismIn computer science, polymorphism is the idea of allowing the same code to be used with different types, resulting in more general and abstract implementations. The concept of polymorphism applies to functions as well as types: A function that can evaluat
• Dynamic scopingscope (programming . Dynamic variable scoping is when you scope a variable in a programming language by replacing the existing variable of that name with a new variable temporarily, for instance for the duration of a function call. This is an easy way to