测试编译器翻译效率的一个很好的方法是自编译:给定的编译器编译自己需要多长时间?对于c++来说，这需要很长的时间(几个小时?)相比之下，在现代机器[1]上，Pascal/Modula-2/Oberon编译器将在不到一秒钟的时间内自行编译。

Go一直受到这些语言的启发，但这种效率的一些主要原因包括:

A clearly defined syntax that is mathematically sound, for efficient scanning and parsing. A type-safe and statically-compiled language that uses separate compilation with dependency and type checking across module boundaries, to avoid unnecessary re-reading of header files and re-compiling of other modules - as opposed to independent compilation like in C/C++ where no such cross-module checks are performed by the compiler (hence the need to re-read all those header files over and over again, even for a simple one-line "hello world" program). An efficient compiler implementation (e.g. single-pass, recursive-descent top-down parsing) - which of course is greatly helped by points 1 and 2 above.

这些原则在20世纪70年代和80年代已经在Mesa、Ada、modala -2/Oberon和其他几种语言中被了解并完全实现，直到现在(在2010年代)才被应用到现代语言中，如Go(谷歌)、Swift (Apple)、c# (Microsoft)和其他几种语言中。

让我们希望这将很快成为常态，而不是例外。要实现这一目标，需要做到两件事:

First, software platform providers such as Google, Microsoft and Apple should start by encouraging application developers to use the new compilation methodology, while enabling them to re-use their existing code base. This is what Apple is now trying to do with the Swift programming language, which can co-exist with Objective-C (since it uses the same runtime environment). Second, the underlying software platforms themselves should eventually be re-written over time using these principles, while simultaneously redesigning the module hierarchy in the process to make them less monolithic. This is of course a mammoth task and may well take the better part of a decade (if they are courageous enough to actually do it - which I am not at all sure in the case of Google).

在任何情况下，是平台推动了语言的采用，而不是相反。

引用:

[1] http://www.inf.ethz.ch/personal/wirth/ProjectOberon/PO.System.pdf, page 6: "The compiler compiles itself in about 3 seconds". This quote is for a low cost Xilinx Spartan-3 FPGA development board running at a clock frequency of 25 MHz and featuring 1 MByte of main memory. From this one can easily extrapolate to "less than 1 second" for a modern processor running at a clock frequency well above 1 GHz and several GBytes of main memory (i.e. several orders of magnitude more powerful than the Xilinx Spartan-3 FPGA board), even when taking I/O speeds into account. Already back in 1990 when Oberon was run on a 25MHz NS32X32 processor with 2-4 MBytes of main memory, the compiler compiled itself in just a few seconds. The notion of actually waiting for the compiler to finish a compilation cycle was completely unknown to Oberon programmers even back then. For typical programs, it always took more time to remove the finger from the mouse button that triggered the compile command than to wait for the compiler to complete the compilation just triggered. It was truly instant gratification, with near-zero wait times. And the quality of the produced code, even though not always completely on par with the best compilers available back then, was remarkably good for most tasks and quite acceptable in general.

虽然上面的大部分都是正确的，但有一点非常重要，没有被真正提到:依赖管理。

Go只需要包含您直接导入的包(就像那些已经导入的包一样)。这与C/ c++形成鲜明对比，在C/ c++中，每个文件都包含x头文件，其中包含y头文件等等。总结:Go的编译需要线性时间w.r.t到导入包的数量，而C/ c++需要指数级的时间。

编译的基本思想实际上非常简单。原则上，递归下降解析器可以以I/O限制的速度运行。代码生成基本上是一个非常简单的过程。符号表和基本类型系统并不需要大量的计算。

然而，降低编译器的速度并不难。

如果存在一个预处理器阶段，其中包含多级包含指令、宏定义和条件编译，尽管这些东西很有用，但加载它并不难。(举个例子，我想到了Windows和MFC头文件。)这就是为什么预编译头文件是必要的。

在优化生成的代码方面，可以向该阶段添加多少处理是没有限制的。

围棋的设计就是要快，这一点已经体现出来了。

Dependency Management: no header file, you just need to look at the packages that are directly imported (no need to worry about what they import) thus you have linear dependencies. Grammar: the grammar of the language is simple, thus easily parsed. Although the number of features is reduced, thus the compiler code itself is tight (few paths). No overload allowed: you see a symbol, you know which method it refers to. It's trivially possible to compile Go in parallel because each package can be compiled independently.

请注意，Go并不是唯一具有这些特性的语言(模块是现代语言的标准)，但它们做得很好。

Go对所有文件导入一次依赖项，因此导入时间不会随着项目大小呈指数增长。 更简单的语言学意味着解释它们需要更少的计算。

还有什么?

Go编译器比大多数C/ c++编译器快得多的原因有很多:

Top reason: Most C/C++ compilers exhibit exceptionally bad designs (from compilation speed perspective). Also, from compilation speed perspective, some parts of the C/C++ ecosystem (such as editors in which programmers are writing their code) aren't designed with speed-of-compilation in mind. Top reason: Fast compilation speed was a conscious choice in the Go compiler and also in the Go language The Go compiler has a simpler optimizer than C/C++ compilers Unlike C++, Go has no templates and no inline functions. This means that Go doesn't need to perform any template or function instantiation. The Go compiler generates low-level assembly code sooner and the optimizer works on the assembly code, while in a typical C/C++ compiler the optimization passes work on an internal representation of the original source code. The extra overhead in the C/C++ compiler comes from the fact that the internal representation needs to be generated. Final linking (5l/6l/8l) of a Go program can be slower than linking a C/C++ program, because the Go compiler is going through all of the used assembly code and maybe it is also doing other extra actions that C/C++ linkers aren't doing Some C/C++ compilers (GCC) generate instructions in text form (to be passed to the assembler), while the Go compiler generates instructions in binary form. Extra work (but not much) needs to be done in order to transform the text into binary. The Go compiler targets only a small number of CPU architectures, while the GCC compiler targets a large number of CPUs Compilers which were designed with the goal of high compilation speed, such as Jikes, are fast. On a 2GHz CPU, Jikes can compile 20000+ lines of Java code per second (and the incremental mode of compilation is even more efficient).