1) JS Engine

JavaScript Engine: The Heart of Execution

A JavaScript engine is a program that executes JavaScript code. It's the core component that allows web browsers and Node.js to run JavaScript. Most modern JavaScript engines are written in C++ for performance reasons, enabling efficient memory management and direct interaction with the operating system. These engines parse, compile, and execute JavaScript code, managing memory, handling function calls, and performing garbage collection. Examples of popular JavaScript engines include:

• V8 (Chrome, Node.js, Deno): Developed by Google, known for its speed and performance.
• SpiderMonkey (Firefox): Developed by Mozilla, one of the earliest JavaScript engines.
• JavaScriptCore (Safari): Developed by Apple.
• Chakra (Edge): Developed by Microsoft.

Components of a JavaScript Engine

• Parser: Analyzes JavaScript code and creates an Abstract Syntax Tree (AST).
• Compiler/Interpreter: Transforms the AST into executable code (machine code or bytecode).
• Call Stack: Manages function execution contexts and tracks the call order.
• Memory Heap: Stores objects, arrays, and other dynamic data.
• Garbage Collector: Automatically reclaims memory that is no longer in use.

1. Program Start & Initialization (Engine Itself)

• Host Environment Interaction: The JavaScript engine is launched by the host (browser, Node.js). The host provides the JavaScript code and access to platform-specific APIs.
• Engine Setup: The engine allocates memory for its internal structures (call stack, heap manager), initializes the garbage collector, and sets up the compiler engine.
• Global Context Creation: The engine creates the global object (e.g., window, global) and the global execution context. This context includes the global object, this (referencing the global object), and variable/lexical environments.
• Call Stack Push: The global execution context is pushed onto the initially empty call stack, initiating program execution.

2. Parsing and Compilation (Compiler Engine)

• Lexical Analysis (Tokenizer): The parser, a component written in C++, breaks the JavaScript code into a stream of tokens.
• Syntax Analysis (Parser): The parser constructs an Abstract Syntax Tree (AST) representing the code's syntactic structure.
• Intermediate Representation (IR) (Optional): Some engines generate an IR for platform-independent optimization, often implemented using C++ data structures.
• Compilation/Interpretation (Compiler/Interpreter):

  JIT Compilation

  The engine analyzes the IR/AST, identifies hot spots, and compiles them into optimized machine code stored in a code cache. Deoptimization may occur. This compilation process is often heavily optimized using C++ for performance.

  Interpretation

  Code paths may be interpreted directly from the AST/IR, often for less frequently executed code.

• Code Generation: The compiler generates machine code for the target CPU architecture, leveraging C++ to generate efficient native code.
• Scope Analysis: the compiler analyzes variable declarations, and determines the scope of each variable.

3. Execution (CPU and Call Stack)

• CPU Instruction Fetch and Decode: The CPU fetches and decodes instructions from the generated machine code.
• Register Operations: The CPU performs arithmetic, logical, and data transfer operations.
• Memory Access:

  Heap Access and Context

  When accessing a variable, the engine checks the current execution context's variable environment. If not found, it traverses the scope chain. The variable's value is retrieved from the heap, which is managed using C++ memory allocation.

  Object Properties

  Objects are stored in the heap. Object property access involves retrieving the object's location and then the property's value.

  Function Closures

  Closures maintain references to outer scope variable environments in the heap, enabling access to captured variables.

  Memory Allocation

  New objects/arrays are allocated memory in the heap, and the execution context maintains references.

• Function Call Mechanism:

  Arguments are passed to the function.

  A new function execution context is created.

  The function's context is pushed onto the call stack.

  The CPU jumps to the function's machine code.

• Call Stack Frames: Each execution context frame stores local variables, arguments, the return address, and this.
• Context Switching: The OS and engine context switch, saving and restoring CPU states for different execution contexts.

4. Function Completion and Call Stack Unwinding

• Return Value Handling: The function's return value is placed in a register or on the stack.
• Context Pop: The function's execution context is popped off the call stack.
• Return Address Jump: The CPU jumps to the return address, resuming execution in the calling function.

5. Garbage Collection (Garbage Collector)

• Memory Allocation Tracking: The engine tracks heap memory allocations.
• Reachability Analysis: The garbage collector, often implemented with C++ algorithms, identifies unreachable objects from root objects (global object, call stack).
• Memory Reclamation: Unreachable objects are marked and their memory is freed.
• Garbage Collection Algorithms: Engines use algorithms like mark-and-sweep or generational garbage collection.
• Context Aware Reachability: The garbage collector takes into account execution contexts and their references to objects in the heap.

6. Program Termination

• Global Context Pop: The global execution context is popped off the call stack.
• Engine Cleanup: The engine releases resources and shuts down.