What is JavaScript?

JavaScript is a high-level, interpreted, dynamically-typed programming language. It is the only language that runs natively in every web browser, making it the backbone of the modern internet.

The One-Sentence Definition

JavaScript is the programming language that makes websites interactive — it handles everything from button clicks to real-time chat apps.

Why JavaScript Exists

In 1995, the web was static — just text and images. Netscape wanted a language that could run inside the browser so users could interact with web pages without reloading. Brendan Eich created JavaScript in just 10 days, and it changed the internet forever.

Today, JavaScript powers:

• Frontend — React, Vue, Angular
• Backend — Node.js, Deno, Bun
• Mobile — React Native, Ionic
• Desktop — Electron (VS Code is built with it!)
• IoT & Robotics — Johnny-Five, Espruino

4 Core Axioms of JavaScript

These are the foundational truths that explain why JavaScript behaves the way it does.

1. Single-Threaded

JavaScript executes one instruction at a time on the main thread. It doesn't run code in parallel by default.

// This runs first
console.log("First");
// This runs second — JS can't do both at once
console.log("Second");

Real-world impact: If you run a heavy computation, the entire UI freezes. That's why we use Web Workers and async patterns.

2. Asynchronous by Nature

Even though JS is single-threaded, it can handle operations like API calls, timers, and file reads without blocking — thanks to the Event Loop (covered later in depth).

console.log("Start");

setTimeout(() => {
  console.log("Timer done"); // Runs LAST
}, 0);

console.log("End");

// Output: Start → End → Timer done

3. Prototype-Based Inheritance

Unlike Java or C++, JavaScript doesn't use classical classes internally. Instead, objects inherit directly from other objects through a prototype chain. The class keyword (added in ES6) is just cleaner syntax — under the hood, it's still prototypes.

const animal = {
  speak() {
    return "...";
  }
};

const dog = Object.create(animal);
dog.speak = function () {
  return "Woof!";
};

console.log(dog.speak()); // "Woof!" (own method)

4. Dynamically Typed

You don't declare the type of a variable — JavaScript figures it out at runtime.

let x = 42;        // x is a Number
x = "hello";       // Now x is a String — no error!
x = true;          // Now x is a Boolean

Trade-off: This makes JS flexible but also introduces subtle bugs. That's why TypeScript (a typed superset of JS) is now the industry standard for large projects.

How JavaScript Runs — The Engine

JavaScript doesn't run on its own. It needs an engine to parse, compile, and execute the code.

What the Engine Does

Your Code (.js)
      ↓
   Parsing → AST (Abstract Syntax Tree)
      ↓
   Interpreter → Bytecode (quick execution)
      ↓
   Optimizing Compiler → Machine Code (hot paths)

This process is called JIT (Just-In-Time) Compilation — a hybrid between interpretation and compilation that gives JavaScript near-native speed.

The Runtime Environment

The engine alone isn't enough. The runtime provides extra tools depending on where your code runs:

Browser Runtime

• DOM (Document Object Model)
• fetch() for network requests
• setTimeout() / setInterval()
• localStorage / sessionStorage
• Web APIs (Geolocation, Notifications, etc.)

Node.js Runtime

• fs (file system access)
• http (create servers)
• process (system info)
• Buffer (binary data)
• No DOM — it's not a browser

Key Difference

// Works in browser, NOT in Node
document.querySelector("#app");

// Works in Node, NOT in browser
const fs = require("fs");

Why Learn JavaScript in 2025+?

1. Ubiquity — it runs everywhere: browsers, servers, mobile, desktop, embedded devices
2. Job Market — most in-demand language year after year on Stack Overflow surveys
3. Ecosystem — NPM has 2M+ packages, the largest package registry in the world
4. Community — massive open-source community, endless tutorials, and resources
5. Full Stack — one language for frontend AND backend (Node.js)

Common Misconception

"JavaScript is Java" — This is wrong. JavaScript was named "JavaScript" purely as a marketing tactic by Netscape in 1995 to ride Java's popularity. They are completely different languages.

Interview Angle

Interviewers love asking:

• "Is JavaScript compiled or interpreted?" → It's JIT-compiled (both)
• "Is JavaScript single-threaded?" → Yes, but it handles async via the Event Loop
• "What's the difference between JavaScript and ECMAScript?" → ECMAScript is the specification, JavaScript is the implementation