Is JavaScript
a Programming Language?

When JavaScript code is loaded, the engine first tokenizes it — breaking the raw text into tokens (keywords, identifiers, operators, literals). Then the parser converts those tokens into an Abstract Syntax Tree (AST): a hierarchical data structure representing the code's grammatical structure.

Tools like Babel, ESLint, Prettier, and TypeScript all work by parsing JS into an AST and then analyzing or transforming it. The AST is the foundation of the entire JavaScript tooling ecosystem.

JavaScript is often described as "interpreted," but modern engines like V8 use a sophisticated multi-tiered JIT (just-in-time) compilation pipeline. V8 specifically uses: Ignition (bytecode interpreter) → Maglev (mid-tier JIT) → TurboFan (optimizing JIT compiler).

Frequently executed "hot" code paths get progressively optimized — eventually compiled down to highly efficient native machine code. This is why modern JavaScript can match or exceed the performance of older compiled languages for many workloads.

JavaScript runs on a single thread — one call stack, one piece of code executing at a time. Yet it handles thousands of concurrent network requests, timers, and UI events without freezing. How? The Event Loop.

When you call fetch(), setTimeout(), or addEventListener(), these are handed off to Web APIs (browser) or libuv (Node.js) running on separate threads. When they complete, their callbacks are placed in the Task Queue or Microtask Queue. The Event Loop continuously checks: "Is the call stack empty?" If yes, it pulls the next callback in — giving JavaScript non-blocking concurrency without multi-threading complexity.

Every time JavaScript runs code — a script, a function, eval() — it creates an Execution Context with its own variable environment, scope chain reference, and this binding. The Global Execution Context is created first; function calls push new contexts onto the call stack.

Hoisting is a result of how the engine processes declarations before execution: var declarations are hoisted and initialized to undefined; let/const are hoisted but uninitialized (the Temporal Dead Zone). Closures occur when an inner function retains access to its outer function's scope chain even after the outer function returns.

JavaScript manages memory automatically via garbage collection. The engine periodically identifies objects that are no longer reachable from any "root" (global variables, the call stack, active closures) and frees their memory.

V8 uses a generational garbage collector: most objects die young (short-lived temporaries), so V8 uses a fast "minor GC" for young objects and a slower "major GC" for long-lived objects. Understanding this helps avoid memory leaks — the most common being uncleared timers, forgotten event listeners, and unintentional global variables.

JavaScript uses prototypal inheritance, not classical inheritance. Every object has an internal [[Prototype]] link to another object (its prototype). When you access a property, JS first checks the object itself, then walks up the prototype chain until it finds it or reaches null.

ES6 class syntax is syntactic sugar over prototypes — it doesn't change the underlying mechanism, just makes the common patterns cleaner to write. Understanding prototypes explains why instanceof works, why array methods are shared across all arrays (via Array.prototype), and how JavaScript's flexible object system actually operates.