Is Go 1.5's bootstrapped compiler slower than the Go 1.4 compiler written in C?

Go 1.5 managed to release a bootstrapped compiler written in Go.
Assuming Go is slower than C, and the earlier Go compiler is written in C, is the bootstrapped compiler going to be slower in compilation time?

Yes, the Go 1.5 compiler is slower, as discussed in the release notes:

> Builds in Go 1.5 will be slower by a factor of about two. The automatic translation of the compiler and linker from C to Go resulted in unidiomatic Go code that performs poorly compared to well-written Go. Analysis tools and refactoring helped to improve the code, but much remains to be done. Further profiling and optimization will continue in Go 1.6 and future releases. For more details, see these slides and associated video.

Again, the compiler was (initially) automatically translated, so after the translation it output the same code as before: your programs aren't slower because the compiler is. The rest of the release notes and the links above shed more light. There are considerations other than compile speeds involved: the authors intend to move faster in Go than they could in C.

I'd recommend upgrading: open-source code will come to depend on 1.5, and if you stay behind you lose a lot of cool stuff, like big reductions in GC latency from pushing most of that work into the background (also discussed in the Performance section linked above; I wrote a bit more about it responding to another question).

You should, as with any big upgrade, test to make sure that stuff like the new default of using all available cores, tweaks to scheduling, or any of the little library behavior changes don't bite you.

Well, PyPy is written in Python and it is known to be faster (sometimes) than CPython written in C.

In the case of Go, the language makes it easier to write more efficient code, so it should not be slower than the older C version. The writers were careful to make sure of this. Rather than faster it is easier to maintain and extend.

C is fast because it is close to the CPU, but the speed of a language is mostly more about the algorithms to produce the more 'advanced' feature (simple to use but advanced compared to CPU features).

A classic example is memory management. The C malloc/free is inherently slow as it reorganises free memory whenever you release it. A garbage collector sounds a lot slower because of the work it needs to do, but your program can release memory and continue on at full speed.