Just-In-Time (JIT) compilation is a system for compiling languages as they are executed, rather than compiling prior to execution. In JIT compilation, the compiling happens during runtime.
JIT compilation can be thought of as a combination of compiled and interpreted languages. Traditionally, compiled languages are languages where the computer translates the code that comprises a program prior to execution. Interpreted languages are not translated by the computer. Instead, they use an interpreter to read and execute the code directly. C is an example of a traditionally compiled language, and Python is an example of an interpreted language. JIT compilation is a mixture of these two methods; source code is directly compiled into machine code at runtime.
Use Cases for JIT compilation
Benefits of JIT compilation
There are multiple benefits of JIT compilation, such as:
Improved Performance for Interpreted Languages
Compiled languages are more performant than interpreted languages. JIT compilation allows interpreted languages to have the increased performance benefits of compilation, without the overhead that comes with traditional compiling.
Increased Efficiency for Compiled Languages
With traditionally compiled languages, programmers must wait for their code to compile prior to starting the execution of a program. JIT compilation does not include this wait time since it compiles the code during the execution phase. Removing this extra step increases efficiency for programmers and the development process.
Decreased Execution Time
JIT compilation can improve optimizations done by the compiler because it has more information than what would be available in a traditional compiling process. This allows JIT compilation to make more performant choices as it compiles, which allows it to run more efficiently in certain cases.
In a traditional compiling process, the programmer is responsible for managing the multiple potential machines the code might run on. For example, if a programmer wanted to execute code to macOS, Android, and Xbox, they would need to compile three times. JIT compilation is more portable than traditional compiling, and instead, the runtime on each system is responsible for managing these relationships rather than the programmer.