On a Monday morning in May 1995, Brendan Eich walked into Netscape Communications’ Mountain View headquarters and started writing a programming language. Ten days later, he had a working prototype. That prototype — initially called Mocha, briefly renamed LiveScript, then finally JavaScript — would become the most widely deployed programming language in history. As of 2026, JavaScript runs on an estimated 98.8% of all websites with client-side scripting. It runs on servers, mobile apps, desktop applications, embedded devices, and even spacecraft. A language built in ten days under intense corporate pressure now processes trillions of interactions every day.
Early Life and Path to Technology
Brendan Eich was born on July 4, 1961, in Pittsburgh, Pennsylvania. He grew up in Palo Alto, California, surrounded by Silicon Valley’s early tech culture. He earned a bachelor’s degree in mathematics and computer science from Santa Clara University in 1983, then a master’s degree in computer science from the University of Illinois at Urbana-Champaign in 1985.
His academic background was serious. At Illinois, he studied under researchers working on compiler design and programming language theory. After graduating, he spent seven years at Silicon Graphics Inc. (SGI), working on operating system and network code. He then moved to MicroUnity Systems Engineering, where he worked on the company’s microprocessor. By 1995, when Netscape recruited him, Eich had over a decade of experience in low-level systems programming — exactly the background needed to build a language runtime from scratch.
Netscape hired him specifically to embed a programming language in the Netscape Navigator browser. The original plan, discussed between Netscape co-founder Marc Andreessen and Sun Microsystems, was to embed Java in the browser. But Java was a compiled, class-based, statically typed language designed for professional software engineers. Netscape wanted something different — a lightweight “glue language” that web designers and hobbyist programmers could use to add interactivity to HTML pages. Eich was told to make it “look like Java” but keep it simple. And he had to do it immediately.
The Breakthrough: JavaScript in Ten Days
The Technical Innovation
Between May 6 and May 15, 1995, Eich built the first JavaScript interpreter. The ten-day timeline was not a choice — it was a deadline imposed by Netscape’s product schedule. Netscape Navigator 2.0 was shipping soon, and the scripting language needed to ship with it. Marketing had already decided on the name “LiveScript” (later changed to “JavaScript” as part of a co-marketing deal with Sun Microsystems, capitalizing on Java’s hype).
Despite the absurd timeline, Eich made several design decisions that turned out to be brilliant. He drew inspiration from three languages. From Scheme (a Lisp dialect), he took first-class functions — the idea that functions are values, just like numbers or strings, that can be passed as arguments, returned from other functions, and stored in variables. From Self (a prototype-based object-oriented language developed at Sun), he took prototypal inheritance — objects inherit directly from other objects, without the complexity of classes. From Java, he took the syntax — curly braces, semicolons, and operator precedence — making JavaScript visually familiar to the largest pool of programmers.
First-class functions and closures are the features that distinguish JavaScript from the “toy language” many dismissed it as during its first decade. They enable patterns that are foundational to modern web development:
// Closures: Eich's most impactful design decision
// A function captures variables from its enclosing scope,
// even after that scope has returned. This enables:
// 1. Data encapsulation (before ES6 modules existed)
function createUserSession(username) {
let loginTime = Date.now();
let actions = [];
return {
getUser: () => username,
logAction: (action) => {
actions.push({ action, timestamp: Date.now() });
},
getSessionDuration: () => {
return Math.floor((Date.now() - loginTime) / 1000);
},
getActions: () => [...actions] // return copy, not reference
};
}
const session = createUserSession("torvalds");
session.logAction("commit");
session.logAction("merge");
console.log(session.getActions());
// [{action: "commit", ...}, {action: "merge", ...}]
// loginTime and actions are private — no way to access directly
// 2. Higher-order functions (functions that take/return functions)
const developers = [
{ name: "Linus", language: "C" },
{ name: "Brendan", language: "JavaScript" },
{ name: "Guido", language: "Python" }
];
const jsDevs = developers.filter(dev => dev.language === "JavaScript");
const names = developers.map(dev => dev.name.toUpperCase());
// These patterns are used millions of times per day in production codeThe event-driven, single-threaded execution model was another consequential choice. JavaScript does not use threads for concurrency. Instead, it uses an event loop — a continuous cycle that processes events (user clicks, network responses, timers) one at a time. This model avoids the complexity of multi-threaded programming (no locks, no race conditions, no deadlocks) at the cost of blocking on long-running operations. The callback pattern, and later Promises and async/await, solved the blocking problem. The event loop model turned out to be ideally suited not just for browser UI programming, but for I/O-heavy server applications — which is why Ryan Dahl chose JavaScript for Node.js in 2009.
But ten days is ten days. JavaScript shipped with genuine design flaws that persist to this day:
// JavaScript's most infamous quirks — all traceable to the 10-day rush
// Type coercion: JS silently converts types in unexpected ways
[] + [] // "" (two arrays become empty string)
[] + {} // "[object Object]"
{} + [] // 0 (block statement + unary plus on array)
"5" - 3 // 2 (string coerced to number for subtraction)
"5" + 3 // "53" (number coerced to string for addition)
// The typeof null bug — a mistake from day one, never fixable
typeof null // "object" (should be "null")
// This happened because the original implementation used tagged pointers:
// objects had tag 000, and null was the NULL pointer (0x00),
// so null was misidentified as an object. Fixing it would break the web.
// Equality operator madness (use === instead of ==)
"" == false // true
0 == false // true
"" == 0 // true
null == undefined // true
NaN === NaN // false (NaN is not equal to itself)
// The 'this' binding problem
const timer = {
seconds: 0,
start() {
// 'this' is lost in the callback — a classic JS trap
setInterval(function() {
this.seconds++; // 'this' is window/undefined, not timer
}, 1000);
// Fix: use arrow function (ES6) — () => { this.seconds++; }
}
};The typeof null === "object" bug is a perfect example of the ten-day constraint. In the original implementation, JavaScript used a type tag system where objects had tag bits of 000. The null value was represented as the machine null pointer (0x00), which also had tag bits of 000. So typeof null returned “object.” The bug was identified almost immediately, but fixing it would break existing websites. It remains in the language 31 years later.
Why It Mattered
JavaScript shipped in Netscape Navigator 2.0 in September 1995. For the first time, web pages could respond to user actions without contacting the server. Form validation, image rollovers, dynamic content updates — these became possible because the browser now had a programming language built in.
Microsoft reverse-engineered JavaScript and created JScript for Internet Explorer 3.0 in 1996. The “Browser Wars” began, with Netscape and Microsoft adding incompatible features to their implementations. This chaos led Netscape to submit JavaScript to ECMA International for standardization in November 1996. The result was ECMAScript — the formal specification that defines the language. The name “JavaScript” was (and remains) a trademark issue, which is why the standard is called ECMAScript while everyone calls the language JavaScript.
The standardization process was critical. Without it, JavaScript would have fragmented into incompatible dialects. Instead, every browser implements the same ECMAScript specification, and developers can write code that works everywhere. The development tools and frameworks we use today all depend on this shared standard.
Beyond JavaScript: Mozilla and Brave
Eich’s career after creating JavaScript was equally eventful. In 1998, Netscape open-sourced its browser code, creating the Mozilla project. Eich co-founded the Mozilla Foundation in 2003 and served as its Chief Technology Officer, overseeing the development of Firefox — the browser that broke Internet Explorer’s monopoly and re-introduced browser competition.
Firefox’s launch in November 2004 was significant. IE held over 90% of the browser market, and Microsoft had disbanded its browser development team, assuming the “Browser Wars” were over. Firefox forced Microsoft to restart IE development, and the resulting competition drove web standards forward faster than would have happened under a monoculture.
In March 2014, Eich was appointed CEO of Mozilla. He resigned eleven days later amid controversy over a $1,000 donation he had made in 2008 to support California’s Proposition 8 (which banned same-sex marriage). The resignation was contentious — some argued it was accountability, others saw it as a litmus test violation of political tolerance. Regardless, it ended Eich’s tenure at Mozilla.
He immediately founded Brave Software and began building the Brave browser. Brave blocks third-party ads and trackers by default and introduced the Basic Attention Token (BAT) — a cryptocurrency-based system where users earn tokens for viewing privacy-respecting ads and can send tokens to content creators. By 2025, Brave had over 70 million monthly active users.
Philosophy and Engineering Approach
Key Principles
Eich’s design philosophy, shaped by his academic background in programming language theory, is visible in both JavaScript’s strengths and its trade-offs.
Multi-paradigm flexibility. JavaScript supports procedural, object-oriented, and functional programming styles. This was intentional. Eich did not want to force programmers into a single paradigm. The result is a language where you can write imperative loops, compose functions, create class hierarchies, or mix all three approaches in the same file. Critics call this inconsistency. Eich calls it pragmatism. The web needed a language that worked for everyone — professional engineers and HTML designers alike.
Backward compatibility is sacred. JavaScript has never removed a feature. The typeof null === "object" bug persists because fixing it would break existing websites. The var keyword remains alongside let and const. The arguments object coexists with rest parameters. This commitment to backward compatibility ensures that a website built in 1997 still works in a 2026 browser. It also means the language accumulates technical debt that can never be repaid.
Extensibility through the standard. Rather than fixing JavaScript’s flaws by creating a new language (as many proposed), the TC39 committee chose to extend the existing language. ES6 (2015) was the biggest single update, adding classes, arrow functions, template literals, destructuring, modules, Promises, Symbol, Map, Set, and generators. Each subsequent yearly release (ES2016 through ES2025) has added targeted improvements. The language Eich built in ten days is now specified in a 900+ page document.
The web platform is the computer. Eich has consistently argued that the open web — not native apps, not walled gardens — should be the primary platform for software distribution. This belief drove his work at Netscape, Mozilla, and Brave. It also explains JavaScript’s expansion from browser scripting to a general-purpose language: if the web is the platform, then its language must be capable of everything.
Legacy and Modern Relevance
JavaScript’s evolution from a hastily-built scripting language to the world’s most used programming language is one of computing’s most improbable success stories. The timeline tells the story:
- 1995-2004: Browser scripting only. DHTML, image rollovers, form validation. Often dismissed as a toy.
- 2005: Ajax (Asynchronous JavaScript and XML) enabled Gmail and Google Maps. Web apps became viable.
- 2006: jQuery simplified cross-browser DOM manipulation. JavaScript became tolerable.
- 2009: Node.js brought JavaScript to the server. It became a “real” programming language.
- 2010-2013: AngularJS, Backbone, Ember — single-page application frameworks emerged.
- 2013-2015: React introduced the virtual DOM and component model. Vue.js offered a progressive alternative.
- 2015: ES6 modernized the language with classes, modules, arrow functions, and Promises.
- 2017-present: TypeScript adoption exploded, adding static types on top of JavaScript’s dynamic foundation.
- 2020-present: Full-stack frameworks (Next.js, Nuxt, SvelteKit) run JavaScript on both client and server.
Today, JavaScript is the connective tissue of the web. It is the only programming language that runs natively in every web browser. The frameworks built on top of it — React, Vue, Svelte, Angular — power the interfaces of nearly every major web application. Node.js runs the backends. TypeScript adds the type safety Eich could not build in ten days. Electron runs the desktop apps (VS Code, Slack, Discord). React Native runs the mobile apps.
The language’s survival and dominance is partly due to Eich’s design decisions — first-class functions and closures turned out to be exactly what asynchronous, event-driven programming needed. It is partly due to the network effect — JavaScript is the only language that runs in the browser, so all browser-targeted languages must compile to it (or to WebAssembly). And it is partly luck and historical accident — the right language appeared at the right time in the right browser.
Tim Berners-Lee created the web’s document layer — static pages linked by hypertext. Eich added the behavioral layer — the ability for those pages to compute, react, and communicate. Torvalds built the servers that host them. Hopper established that programming languages should be human-readable. Together, these contributions form the stack that runs the modern internet.
Key Facts
- Born: July 4, 1961, Pittsburgh, Pennsylvania
- Known for: Creating JavaScript (1995), co-founding Mozilla, founding Brave Software
- Education: B.S. Mathematics and Computer Science, Santa Clara University (1983); M.S. Computer Science, University of Illinois at Urbana-Champaign (1985)
- Key projects: JavaScript (1995), Mozilla/Firefox (1998-2014), Brave Browser (2015-present)
- Career: Silicon Graphics (1985-1992), MicroUnity (1992-1995), Netscape (1995-2003), Mozilla (2003-2014), Brave Software (2015-present)
- JavaScript usage: ~98.8% of websites with client-side scripting, estimated 20+ million developers
Frequently Asked Questions
Who is Brendan Eich?
Brendan Eich is an American computer scientist and programmer who created the JavaScript programming language in May 1995 while working at Netscape Communications. He went on to co-found the Mozilla Foundation (which created the Firefox browser) and later founded Brave Software, the company behind the privacy-focused Brave browser.
What did Brendan Eich create?
Eich created JavaScript, the programming language that runs on virtually every website. He built the first prototype in ten days in May 1995. Despite the rushed timeline, JavaScript’s core features — first-class functions, closures, and prototypal inheritance — proved remarkably well-suited to web development. He also co-created the Mozilla project and the Brave browser.
Why is Brendan Eich important to computer science?
Eich created the only programming language that runs natively in web browsers, making it the most widely deployed language in computing history. JavaScript transformed the web from a static document system into an interactive application platform. Without JavaScript, there would be no Gmail, no Google Maps, no modern web applications. Every interactive element on every website runs on the language Eich designed.
What is Brendan Eich doing today?
Eich is the CEO of Brave Software, the company behind the Brave browser. Brave blocks third-party ads and trackers by default and uses a cryptocurrency-based system (Basic Attention Token) to compensate users and content creators. As of 2025, Brave has over 70 million monthly active users. Eich remains an active voice in debates about web standards, browser privacy, and the open web.
