How JIT Compilation Supercharges Your JavaScript

JavaScript engines use the JIT(just in time) compiler to execute the code.

I know you must be wondering what the hell is JIT and how it works?

gif

Suppose: you're building a new web app with all the latest JavaScript features. Everything looks great, but then you notice it's... kind of slow. Back in the day, this was a massive problem for JavaScript developers. The language was literally too slow for complex applications.

What happened? The secret is called JIT compilation.

let’s understand JIT

1. Interpreted Languages

Code is executed line by line by an interpreter
No machine code is generated in advance
Pros: Very fast (runs immediately)
Cons: Slower execution. Code is re-parsed every time.

Interpreter

// Example: interpreted execution
let x = 5;
let y = 10;
console.log(x + y); // Interpreter reads & runs line by line

2. Compiled Languages

Source code is fully compiled into machine code before execution.
Pros: Extremely fast runtime execution
Cons: Slow startup, less flexible

compiler Example: C, C++ are compiled before running.

Why JIT Was Introduced

Slow performance of interpreted code: Interpreters reprocess the same code repeatedly. JIT caches machine code for faster execution.
Balance between speed & execution speed: Interpreters start instantly; compilers run fast after compiling. JIT gives us both.

How JIT Actually Works

1. Parsing → AST

JavaScript code is parsed into an Abstract Syntax Tree (AST) - a structured representation of your code.

2. Bytecode Generation

The AST is converted to bytecode, which can already run.

3. Hot Code Detection (Profiling)

It's basically profiling your code to see which parts get used the most. We call these "hot code". The engine monitors which functions/loops run most often.

function add(a, b) { return a + b; }

// This loop gets flagged as "hot code"
for (let i = 0; i < 1_000_000; i++) {
  add(2, 3); 
}

4. JIT Compilation

Hot code is compiled into optimized machine code that runs directly on the CPU → much faster.

5. Optimization & De-optimization

If something changes (like a variable type), the engine can backtrack and re-optimize as needed.

JIT

Final Note: Just-In-Time (JIT) compilation combines the features of both an interpreter and a compiler.