Who Invented JavaScript? The Brendan Eich Story

JavaScript was invented by Brendan Eich, an American computer scientist who created the language in approximately 10 days in May 1995 while working at Netscape Communications. What makes this story remarkable is not just the speed of creation, but the fact that a language built under extreme time pressure by a single developer went on to become the most widely used programming language in history, running on virtually every computing device with a web browser.

Understanding Brendan Eich's background, the constraints he faced, and the design decisions he made helps explain why JavaScript works the way it does today. Every quirk, every design pattern, and every strength of the language traces back to the choices made during those 10 days and the influences Eich brought to the table.

Brendan Eich's Background

Before joining Netscape, Brendan Eich had a strong academic and professional background in programming language design. He studied physics and mathematics at Santa Clara University, then earned a master's degree in computer science from the University of Illinois at Urbana-Champaign.

His professional experience before Netscape included work at Silicon Graphics (SGI) on networking and operating system code, and at MicroUnity Systems on digital signal processing. Crucially, he had deep familiarity with programming language theory, particularly with two languages that would heavily influence JavaScript's design:

This combination of influences is what makes JavaScript unique. Most languages of the 1990s were either purely object-oriented (like Java and C++) or purely functional (like Haskell and ML). Eich blended functional programming concepts (from Scheme) with a prototype-based object system (from Self) and wrapped it in Java-like syntax (per Netscape's business requirement).

The 10-Day Creation Sprint

The Business Context

In early 1995, Netscape Navigator was the dominant web browser with over 80% market share. The company's co-founder Marc Andreessen wanted to add a scripting language to the browser that would be accessible to non-programmers: web designers, amateur developers, and hobbyists who found Java too complex.

Netscape had a licensing agreement with Sun Microsystems (Java's creator). The original plan was to embed Java in the browser as a complement to a simpler scripting language. The scripting language would handle quick tasks (form validation, simple animations) while Java applets would handle complex computation.

Eich was hired in April 1995, and his assignment was clear: create a language that looked like Java (familiar syntax), but was simpler and more accessible, similar to Microsoft's Visual Basic. The deadline was brutal because Netscape needed to ship the language with Navigator 2.0 before Microsoft could build a competing browser scripting solution.

What Eich Built

In those 10 days, Eich created the core of what would become JavaScript:

javascript

// Core features Eich built in those 10 days (1995)
 
// 1. Dynamic typing - variables hold any type
var name = "Brendan";
var age = 34;
var isCreator = true;
 
// 2. First-class functions (from Scheme influence)
function greet(person) {
  return "Hello, " + person + "!";
}
 
var sayHi = greet; // functions are values, assignable to variables
sayHi("World");    // "Hello, World!"
 
// 3. Prototype-based objects (from Self influence)
var language = {
  name: "JavaScript",
  year: 1995,
  describe: function () {
    return this.name + " was created in " + this.year;
  }
};
 
// 4. Event-driven model for browser interaction
document.onclick = function () {
  alert("You clicked the page!");
};

The Naming Journey

The language went through three names reflecting the chaotic business dynamics at Netscape:

1. Mocha (May 1995): Eich's internal codename during development
2. LiveScript (September 1995): The name when it first shipped in Netscape Navigator 2.0 beta
3. JavaScript (December 1995): Renamed as part of the Sun Microsystems marketing partnership

The "JavaScript" name was a deliberate marketing decision. Java was the most hyped technology of 1995, and Netscape wanted to position their scripting language as "Java's little brother" for the web. Eich and others at Netscape have repeatedly noted this was a business decision, not a technical one. The two languages share syntax superficialities but are fundamentally different in design philosophy.

Eich's Key Design Decisions

Several decisions Eich made during the creation sprint and early development had lasting consequences for how billions of developers write code today.

First-Class Functions

Eich's most impactful decision was making functions "first-class citizens." This means functions in JavaScript are values that can be stored in variables, passed as arguments to other functions, and returned from functions. This concept came from Scheme and is the foundation for callbacks, event handlers, Promises, and virtually every modern JavaScript pattern.

javascript

// First-class functions: the most consequential design decision
 
// Functions as values
var operations = {
  add: function (a, b) { return a + b; },
  subtract: function (a, b) { return a - b; },
  multiply: function (a, b) { return a * b; }
};
 
function calculate(operation, x, y) {
  return operations[operation](x, y);
}
 
calculate("add", 10, 5);      // 15
calculate("multiply", 4, 7);  // 28
 
// This pattern enables callbacks (the backbone of async JavaScript)
function fetchData(url, onSuccess, onError) {
  // In 1995, this pattern enabled non-blocking browser operations
  var xhr = new XMLHttpRequest();
  xhr.open("GET", url);
  xhr.onload = function () {
    if (xhr.status === 200) {
      onSuccess(JSON.parse(xhr.responseText));
    } else {
      onError(new Error("Request failed: " + xhr.status));
    }
  };
  xhr.send();
}

Prototype-Based Inheritance

Instead of Java's class-based inheritance, Eich chose Self's prototype-based model. Objects inherit directly from other objects through a "prototype chain," with no classes required. This was simpler to implement and more flexible, though it confused generations of developers coming from class-based languages.

javascript

// Prototype-based inheritance (Eich chose this over Java-style classes)
 
// Base object
var vehicle = {
  type: "unknown",
  wheels: 0,
  describe: function () {
    return this.type + " with " + this.wheels + " wheels";
  }
};
 
// Create a new object that inherits from vehicle
var car = Object.create(vehicle);
car.type = "sedan";
car.wheels = 4;
car.honk = function () {
  return "Beep beep!";
};
 
car.describe(); // "sedan with 4 wheels" (inherited method)
car.honk();     // "Beep beep!" (own method)
 
// The prototype chain: car -> vehicle -> Object.prototype -> null

Dynamic Typing

Eich made JavaScript dynamically typed, meaning variables can hold any type of value and types are checked at runtime, not compile time. This made the language more accessible to non-programmers (no type declarations needed) but introduced a category of bugs that statically typed languages catch automatically.

The typeof null Bug

Perhaps the most famous bug in JavaScript history: typeof null returns "object" instead of "null". This happened because of how Eich implemented type tags in the original engine. Values were stored with a type tag, and the tag for objects was 0. null was represented as the NULL pointer (address 0), so its type tag was read as 0, matching "object." Eich has confirmed this was a bug, but fixing it would break too much existing code.

javascript

// The most famous bug in JavaScript
console.log(typeof null);       // "object" (bug since 1995)
console.log(typeof undefined);  // "undefined" (correct)
console.log(typeof 42);         // "number" (correct)
console.log(typeof "hello");    // "string" (correct)
console.log(typeof true);       // "boolean" (correct)
console.log(typeof {});         // "object" (correct)
 
// The safe way to check for null
var value = null;
console.log(value === null);    // true (use strict equality)

After JavaScript: Eich's Continued Impact

Mozilla and Firefox

After Netscape was acquired by AOL in 1999, Eich became a key figure in the Mozilla project, the open-source initiative that grew out of Netscape's decision to release its browser source code. He served as Mozilla's CTO and briefly as CEO. The Mozilla project produced Firefox, which played a crucial role in breaking Internet Explorer's browser monopoly and pushing web standards forward.

The Brave Browser

In 2015, Eich co-founded Brave Software and created the Brave browser, which focuses on privacy and blocks ads and trackers by default. Brave also introduced the Basic Attention Token (BAT), a cryptocurrency-based system for compensating content creators. As of 2026, Brave has over 70 million monthly active users.

The Legacy: How One Engineer Shaped the Web

The language Brendan Eich created in 10 days now:

• Runs on approximately 98% of all websites
• Powers the frontend of every major web application (Gmail, YouTube, Netflix, X, Reddit)
• Runs on servers via Node.js at Netflix, PayPal, LinkedIn, and NASA
• Has the largest package ecosystem in any programming language (npm: 2M+ packages)
• Has been the most used language in the Stack Overflow Developer Survey for 11+ consecutive years
• Is maintained by the TC39 committee at Ecma International, with annual specification updates

Best Practices: Lessons from Eich's Design Philosophy

Simplicity enables adoption. Eich deliberately made JavaScript simpler than Java because the target audience was web designers, not systems programmers. This principle still applies: write JavaScript that is readable and straightforward, even when you know advanced patterns. The best code is code your teammates can understand immediately.

Flexibility is a feature, not a bug. JavaScript's dynamic typing and prototype-based inheritance give you multiple ways to solve problems. Instead of fighting this flexibility, embrace it. Use object literals when you need a quick data structure. Use classes when you need formal inheritance. Use functions when you need reusable behavior. The language supports your style.

Backward compatibility matters above all. JavaScript has never broken old code. A script written in 1995 still runs in 2026 browsers. This commitment to backward compatibility is why the web works. When writing your own code, think about how changes affect existing users and consumers of your APIs.

First-class functions are your greatest tool. Eich's Scheme influence gave JavaScript its most powerful feature. Callbacks, array methods (.map(), .filter(), .reduce()), Promises, event handlers, and React components all depend on treating functions as values. If you master one concept in JavaScript, make it this one.

Common Mistakes About JavaScript's Origin

Claiming JavaScript was "copied from Java." JavaScript's C-style syntax (braces, semicolons, keywords) resembles Java, but the language's core architecture came from Scheme (functional) and Self (prototypal). The Java-like syntax was a business requirement from Netscape management, not a technical design choice.

Dismissing the 10-day timeline as meaning "JavaScript was poorly designed." The 10-day sprint produced the language prototype. Eich and the Netscape team continued refining it afterward. Many of JavaScript's strongest features (first-class functions, closures, object literals) were deliberately designed, not accidental. The genuine bugs (like typeof null) are relatively minor compared to the overall design.

Saying Brendan Eich "just got lucky." Eich had deep expertise in programming language design, including knowledge of Scheme, Self, and compiler theory. The design decisions that made JavaScript so enduring (first-class functions, prototype chains, event-driven model) came from years of language research, not luck.

Attributing JavaScript's success solely to browser monopoly. While being the only browser language helped, JavaScript's explosion beyond the browser (Node.js, React Native, Electron) proves the language has genuine qualities that developers value: flexibility, a massive ecosystem, and rapid iteration capability.

Next Steps