Tutorial: Metacompilers Part 1

While we're at it, here is my mandatory Shameless Plug™. I also wrote 30+ compilers, starting from MetaII, but did not publish them. Quite the enlightening exercise, I now understand much about top down parsing.

First, there's the computer. It's a hunk of metal that can receive instructions and produce a result. It's an interpreter that can interpret machine language.

Then there are compilers. A compiler is a heap of binary data, that, when interpreted by the computer, will cause it to transform some input into a binary heap of data the computer can interpret.

Then there are self-hosting compilers. They're just like the compilers above, but some particular input will cause them to output a binary heap that's identical to themselves. At this point, we don't really care about the binary any more, we care about that particular input: the source code.

Most serious compilers are self hosting: Just like the compiler above, they are implemented in the same language than the one they can compile. GCC for instance can compile C is (was?) itself written in C.

The final stage is meta-compiling. A meta-compiler is a self-hosting compiler, whose source code is written in some DSL that's specialised in compiler construction. Though most of the time those compilers don't produce binary code directly, but some other encoding that other compilers (or interpreters) can understand.

Does that help?

Technically, a compiler is a translator between any two languages.

Transpiler is a term that has grown in use to mean translating between two languages of similar abstraction, but it is by no means any more correct than compiler.