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 while some interpreted 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 or threaded code, which is then executed by a bytecode interpreter. Examples include Python, and Java
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):
For faster development of applications, programmers choose Interpredted languages (RAD - Rapid Application development)
It is easy to use and develop applications, flexible and provides many features like
platform independence (Java's byte code, for example)
dynamic typing
ease of debugging (It is easier to get source code information in interpreted languages)
small program size (Since interpreted languages have flexibility to choose instruction code)
object polymorphism
dynamic scoping
Interpreted Languages:
ASP Web page scripting language
BASIC
COBOL
A compiled language is a programming language whose implementations are typically compilers (translators which generate machine code from source code), and not interpreters (step-by-step executors of source code, where no translation takes place).
A program translated by a compiler tends to be much faster than an interpreter executing the same program: even a 10:1 ratio is not uncommon. The mixed solution's efficiency is typically somewhere in between. The downsides of the "compiler" solution are the inherent complexity of a good implementation, and longer edit-run cycles.
A pure compiler implementation is the typical solution for low-level languages, because it comes out as more "natural", and because of efficiency concerns; however with some effort it is always possible to write compilers even for traditionally interpreted languages
Some languages that are commonly considered to be compiled:
C, C++
Delphi
Pascal