开始用“过去的冲击波”来思考

很久很久以前，有一个计算机王国 解释器和编译器。的优点引起了各种各样的争论 一个比另一个。当时的普遍意见是这样的:

解释器:快速开发(编辑和运行)。执行速度慢，因为每个语句都必须被解释为 每次执行的机器代码(想想这对于执行了数千次的循环意味着什么)。 编译器:开发(编辑、编译、链接和运行)缓慢。编译/链接步骤可能会花费大量时间)。快 来执行。整个程序已经是原生机器代码了。

运行时有一到两个数量级的差异 解释程序和编译程序之间存在性能差异。其他的区别 点，例如代码的运行时可变性，也有一些兴趣，但主要是 区别围绕着运行时性能问题。

今天的情况已经发展到这样的程度，编译/解释的区别是 几乎无关紧要。许多 编译语言调用的运行时服务并非如此 完全基于机器代码。而且，大多数解释型语言都被“编译”成字节码 之前执行。字节码解释器非常高效，可以与一些编译器生成的解释器相匹敌 从执行速度的角度来看代码。

典型的区别是编译器生成本机机器码，解释器读取源代码 使用某种运行时系统动态生成机器代码。 如今，经典的诠释者已所剩无几——几乎全部 编译成字节码(或其他一些半编译状态)，然后在虚拟“机器”上运行。

编译器和解释器做同样的工作:将一种编程语言翻译成另一种编程语言，通常更接近硬件，通常是直接可执行的机器代码。

Traditionally, "compiled" means that this translation happens all in one go, is done by a developer, and the resulting executable is distributed to users. Pure example: C++. Compilation usually takes pretty long and tries to do lots of expensive optmization so that the resulting executable runs faster. End users don't have the tools and knowledge to compile stuff themselves, and the executable often has to run on a variety of hardware, so you can't do many hardware-specific optimizations. During development, the separate compilation step means a longer feedback cycle.

Traditionally, "interpreted" means that the translation happens "on the fly", when the user wants to run the program. Pure example: vanilla PHP. A naive interpreter has to parse and translate every piece of code every time it runs, which makes it very slow. It can't do complex, costly optimizations because they'd take longer than the time saved in execution. But it can fully use the capabilities of the hardware it runs on. The lack of a separrate compilation step reduces feedback time during development.

But nowadays "compiled vs. interpreted" is not a black-or-white issue, there are shades in between. Naive, simple interpreters are pretty much extinct. Many languages use a two-step process where the high-level code is translated to a platform-independant bytecode (which is much faster to interpret). Then you have "just in time compilers" which compile code at most once per program run, sometimes cache results, and even intelligently decide to interpret code that's run rarely, and do powerful optimizations for code that runs a lot. During development, debuggers are capable of switching code inside a running program even for traditionally compiled languages.

首先，澄清一下，Java不是完全静态编译和以c++的方式链接的。它被编译成字节码，然后由JVM解释。JVM可以对本机机器语言进行即时编译，但不必这样做。

更重要的是:我认为交互性是主要的实际区别。由于所有内容都是解释的，所以您可以截取一小段代码，解析并根据环境的当前状态运行它。因此，如果您已经执行了初始化变量的代码，则可以访问该变量，等等。它真的很适合函数式风格。

然而，解释成本很高，特别是当您有一个包含大量引用和上下文的大型系统时。根据定义，这是一种浪费，因为相同的代码可能必须解释和优化两次(尽管大多数运行时都为此进行了缓存和优化)。不过，您仍然需要支付运行时成本，并且经常需要运行时环境。您也不太可能看到复杂的过程间优化，因为目前它们的性能还没有充分的交互性。

因此，对于不会有太大变化的大型系统，以及某些语言，更有意义的是预编译和预链接所有内容，做所有可以做的优化。最终会得到一个非常精简的运行时，该运行时已经针对目标机器进行了优化。

至于生成可执行文件，恕我直言，这一点关系不大。通常可以从编译语言创建可执行文件。但是您也可以使用解释语言创建可执行文件，只不过解释器和运行时已经打包在可执行文件中，并且对您隐藏了。这意味着您通常仍然需要支付运行时成本(尽管我确信对于某些语言，有方法将所有内容转换为可执行树)。

我不同意所有的语言都可以互动。某些语言，如C语言，与机器和整个链接结构紧密相连，我不确定您是否能够构建一个有意义的完整的交互式版本

语言本身既不编译也不解释，只有语言的特定实现才是。Java就是一个很好的例子。有一个基于字节码的平台(JVM)、一个本机编译器(gcj)和一个用于Java超集(bsh)的互用器。那么Java现在是什么呢?字节码编译，本机编译还是解释?

其他既编译又解释的语言有Scala、Haskell或Ocaml。每种语言都有一个交互式解释器，以及一个字节码或本机机器码的编译器。

所以一般来说，用“编译型”和“解释型”来划分语言并没有多大意义。

The Python Book©2015 Imagine Publishing Ltd，简单地通过第10页中提到的以下提示来区分差异:

像Python这样的解释型语言是指将源代码转换为机器码，然后在每次程序运行时执行的语言。这与编译语言(如C)不同，后者只将源代码转换为机器代码一次——然后在程序每次运行时执行生成的机器代码。

从http://www.quora.com/What-is-the-difference-between-compiled-and-interpreted-programming-languages

There is no difference, because “compiled programming language” and “interpreted programming language” aren’t meaningful concepts. Any programming language, and I really mean any, can be interpreted or compiled. Thus, interpretation and compilation are implementation techniques, not attributes of languages. Interpretation is a technique whereby another program, the interpreter, performs operations on behalf of the program being interpreted in order to run it. If you can imagine reading a program and doing what it says to do step-by-step, say on a piece of scratch paper, that’s just what an interpreter does as well. A common reason to interpret a program is that interpreters are relatively easy to write. Another reason is that an interpreter can monitor what a program tries to do as it runs, to enforce a policy, say, for security. Compilation is a technique whereby a program written in one language (the “source language”) is translated into a program in another language (the “object language”), which hopefully means the same thing as the original program. While doing the translation, it is common for the compiler to also try to transform the program in ways that will make the object program faster (without changing its meaning!). A common reason to compile a program is that there’s some good way to run programs in the object language quickly and without the overhead of interpreting the source language along the way. You may have guessed, based on the above definitions, that these two implementation techniques are not mutually exclusive, and may even be complementary. Traditionally, the object language of a compiler was machine code or something similar, which refers to any number of programming languages understood by particular computer CPUs. The machine code would then run “on the metal” (though one might see, if one looks closely enough, that the “metal” works a lot like an interpreter). Today, however, it’s very common to use a compiler to generate object code that is meant to be interpreted—for example, this is how Java used to (and sometimes still does) work. There are compilers that translate other languages to JavaScript, which is then often run in a web browser, which might interpret the JavaScript, or compile it a virtual machine or native code. We also have interpreters for machine code, which can be used to emulate one kind of hardware on another. Or, one might use a compiler to generate object code that is then the source code for another compiler, which might even compile code in memory just in time for it to run, which in turn . . . you get the idea. There are many ways to combine these concepts.