Skip to main content
NEW
New questions added!
Explore now
frontendpro
en
Sign in
Pricing
Get full access
en
Sign in
frontendpro
Dashboard
Courses
Interview guides
Practice
Technical articles
All articles
JavaScript
React
Next.js
TypeScript
JS Engine
Performance
Design Patterns
Algorithms
Authentication
Backend
Design
Frontend
About FrontendPro
JS Engine
JS Engine
Default
Title
18
docs
0
Read
Filters
1
1
1. JS Value Representation
How a JavaScript engine (primarily V8) stores values in memory, and why that single design decision ripples through everything else.
2
2. Parser & AST
How raw source text becomes a structured tree the engine can execute - and why this stage quietly shapes your app's startup time.
3
3. Bytecode Interpreter (Ignition)
V8's baseline tier: it turns the AST into compact bytecode, runs it, and quietly gathers the profiling data that makes everything faster later.
4
4. JIT Compiler (TurboFan)
V8's optimizing compiler: it turns hot bytecode plus type feedback into fast native machine code - and gracefully unwinds when its assumptions turn out to be wrong.
5
5. Hidden Class & Shapes
How V8 gives dynamic, dictionary-like objects the same fast, struct-style property access you'd expect from a statically typed language.
6
6. Inline Cache (IC)
The mechanism that makes a repeated obj.x fast by remembering, right at that spot in the code, where x was found last time.
7
7. Object Optimization
How V8 physically stores an object's properties, what keeps an object on the fast path, and what quietly drops it onto the slow one.
8
8. Array Optimization
How V8 represents arrays through "elements kinds," why packed integer arrays are the fastest thing going, and how a single careless line can permanently slow an array down.
9
9. Deoptimization
What happens the moment the JIT's optimistic assumptions break - and why the truly expensive thing isn't a single deopt but a deopt loop.
10
10. Execution Context
The internal environment a piece of JavaScript runs inside - the concept that explains hoisting, the temporal dead zone, this, and the call stack all at once.
11
WebAssembly Integration
How WebAssembly runs side by side with JavaScript inside the very same engine - what it's good for, and where the boundary between the two costs you.
12
Engine Threads & Concurrency
"JavaScript is single-threaded" is true in a precise and limited sense - your code runs on one thread, but the engine and host quietly use many.
13
Module System
How JavaScript code gets split across files, linked together, and loaded - and why ES Modules behave differently from the older CommonJS in ways that actually matter.
14
Runtime APIs (Browser / Node)
The engine runs the language; the host provides the APIs you actually build with. Keeping this line clear explains a surprising amount about portability.
15
Event Loop & Async Runtime
How a single-threaded language manages to handle timers, network requests, and file I/O all at once without ever blocking.
16
Garbage Collection
How V8 automatically figures out which memory is no longer needed and reclaims it - and why modern GC manages to do this without freezing your program.
17
Memory Layout
Where JavaScript data actually lives - the split between stack and heap, how V8 organizes its heap into generations, and what a "memory leak" even means in a garbage-collected language.
18
Closures & Scope Chain
How JavaScript decides which variable a name refers to across nested functions, and how closures keep variables alive long after the function that created them has returned.
