Question

The title pretty much sums it up but I was wondering why systems like .net compile code every time it is run instead of just compiling it once on the target machine?

Answer 1

There are two things to be gained by using an intermediate format like .NET or Java:

1. You can run the program on any platform, exactly because the code is represented in an intermediate format instead of native code. You just need to write an interpreter for the intermediate format.
2. It allows for some run-time optimizations which are not (easily) possible at compile-time: for example, you can take advantage of special features on new CPUs, even if those CPUs didn’t exist when you wrote your program – only the JIT compiler needs to know about that.

Now, as for why you might not want to perform the compilation on the first run and then just cache that – there can be a couple of reasons for that as well.

If you compile before startup, then the user has to wait a lot longer for that first run – at that point in time, you can’t know what the user will actually use. By only compiling what you need, when you need it, you can start much quicker, simply because you have less work to do, and you don’t store a lot of code that the user will never use (which for a large program can be a lot of code).

If you start caching the JIT’ted code across sessions, you need to keep track of what has already been compiled and then store it to disk. For a large program, you might have a lot of native code to load from disk. Disk I/O is quite expensive, so it might just take longer to wait for the disk than to re-JIT it. Additionally, you need to keep track of how long that cache is usable. If the hardware changes, you might want to re-JIT in order to apply some new optimizations. If the program changes, you can’t use any of your old compiled code. If the run-time compiler changes, then a security bug might have been fixed, and you need to recompile to make sure that bug doesn’t remain in your native code.

Basically, the JIT compiler suddenly has a lot more work to do (including disk I/O to deal with the cache) and becomes much more complicated and slow, reducing the point of JIT’ing.

Now, that doesn’t mean that it can’t sometimes be advantageous to pre-compile certain assemblies, and as Matthew Ferreira points out, that’s what the ngen tool can do – but in the general case, it’s just not worth doing that, because JIT compilation is often more than fast enough.