C++ – How to Convert an Interpreter to a Compiler

There's confusion in the question.

There's an assumption that type checking is slow, which isn't necessarily the case.

The question also seems to confuse the process of type dispatch with type checking, and they are two different things. One is a process that's done at run time, the other a process at compilation time. I suspect the question is really asking about type dispatch.

It is type dispatch that can introduce overhead at runtime, because the computation spends time with instructions that decide, dynamically, what action to take, based on the types of values it sees at run time. e.g. in a dynamic language, if I apply "+" on two things, I might mean numeric addition, or string concatenation, so I need to spend time looking at what's at hand to decide what to do. There are evaluation strategies that can reduce the cost of dynamic dispatch. (e.g. tracing JITs)

With regards to doing type-checking in JavaScript, see: http://www.cs.brown.edu/~sk/Publications/Papers/Published/gsk-flow-typing-theory/. For a more general overview of how type checkers work, a standard programming language textbook will cover the algorithms. For example, http://www.cs.brown.edu/~sk/Publications/Books/ProgLangs/

Writing a compiler seems like a much harder problem than an interpreter.

That might be true today, but I would argue that it was not the case some 60 years ago. A few reasons why:

• With an interpreter, you have to keep both it and the program in memory. In an age where 1kb of memory was a massive luxury, keeping the running memory footprint low was key. And interpreting requires a bit more memory than running a compiled program.
• Modern CPUs are extremely complex with huge catalogs of instructions. So writing a good compiler is truly a challenge. Old CPUs were much simpler, so even compilation was simpler.
• Modern languages are much more complex than old languages, so even compilers are much more complex. Old languages would thus have simpler compilers.