Brendan Eich is tied to one of programming history’s best-known anecdotes: JavaScript was supposedly “created in ten days.” That is accurate if it refers to the first prototype, built at Netscape in May 1995. It is misleading if it suggests that today’s language emerged fully formed in that sprint. Modern JavaScript reflects three decades of standardization, competing implementations, corrections, and compromises with one of the Web’s strongest constraints: existing pages should keep working.
Eich’s story is compelling precisely because of that tension. Under intense time pressure, he designed a language that had to be easy to embed in a page while combining ideas from Scheme and Self behind syntax familiar to C and Java programmers. A short-term commercial requirement ended up producing the browser’s universal native programming language.
Before Netscape: a language engineer
Brendan Eich was born in Pittsburgh in 1961. He studied mathematics and computer science and earned a master’s degree from the University of Illinois Urbana-Champaign in 1986. Before joining Netscape, he worked at companies including Silicon Graphics and MicroUnity on compilers and systems.
That background matters. Eich was not improvising without a foundation: he understood the trade-offs between language design, implementation, and performance, and he had a particular interest in Scheme, a Lisp dialect in which functions are central building blocks.
1995: giving Web pages behavior
In the mid-1990s, the Web was still primarily a collection of documents. HTML described a page and the browser rendered it; many interactions required another round trip to the server.
Netscape Navigator was then a leading browser. Netscape wanted page authors to add behavior directly in the browser without adopting a heavyweight development toolchain. At the same time, the company was working with Sun around Java, positioned for more structured applications. The new scripting language needed to be lighter, immediately usable from HTML, and available without compilation.
Eich joined Netscape in April 1995. In May he built the prototype known as Mocha in roughly ten days. Work continued before release: the language became LiveScript and then JavaScript late in 1995, at a moment when Java had enormous marketing visibility.
The name has caused confusion ever since. JavaScript is not a simplified edition of Java. The languages differ in their type systems, object models, and execution environments. Their most obvious resemblance comes from deliberately familiar C-family syntax: braces, operators, and control structures.
Scheme and Self beneath a familiar surface
Under that surface, JavaScript treats functions as first-class values. A function can be stored in a variable, passed to another function, or returned as a result. This Scheme-like flexibility is especially well suited to an event-driven browser, where a function can respond to a click, user input, or the completion of an operation.
For objects, Eich drew in part on Self. Rather than making classes the fundamental mechanism, an object can delegate property lookup to another object through a prototype chain. The class syntax added much later did not replace this model; it offers a more familiar way to work on top of it.
JavaScript also adopted dynamic typing and many implicit conversions. Those choices made small scripts quick to write but also created behavior that can be surprising. Some of the language’s notorious quirks are best understood as products of the original compromise: JavaScript had to be approachable, expressive, and ready extremely quickly.
Eich simultaneously developed the first engine, the ancestor of SpiderMonkey. Designing the syntax and implementation together made rapid experimentation possible, but left little time to reconsider decisions before public Web pages began depending on them.
When quirks become compatibility contracts
On the Web, a published mistake is difficult to erase. Once thousands of sites rely on a behavior, changing it incompatibly can break those sites. Implicit conversions, historical scoping rules, the behavior of this, and the coexistence of null and undefined therefore belong to an inheritance modern JavaScript has to manage rather than simply delete.
This constraint explains both JavaScript’s rough edges and its remarkable continuity. Standards generally add safer or clearer mechanisms without abruptly removing the old ones.
It also highlights an important distinction: JavaScript is not the browser. The language defines values, functions, objects, and operations. APIs such as the DOM, events, fetch, and storage are supplied by the Web environment. Historical incompatibilities could come from the language itself or from the browser APIs around it.
From JavaScript to ECMAScript
Netscape’s success quickly produced competing implementations. Microsoft introduced JScript in Internet Explorer, while browsers developed proprietary behaviors and APIs. Without a common foundation, Web authors risked having to write different code for different browsers.
Netscape submitted the language to Ecma International in 1996. The first edition of ECMA-262 appeared in 1997 under the name ECMAScript. This was a crucial shift: the core rules of the language were no longer defined solely by one vendor’s browser.
JavaScript remains the historical and everyday name; ECMAScript is the standardized specification. Browsers implement that specification and then provide the Web APIs around it.
Standardization was not smooth. The ambitious ECMAScript 4 effort ran into deep disagreements in the 2000s over how far the language should change. The eventual compromise led to ECMAScript 5 in 2009. ECMAScript 2015 (ES6) then became a major milestone, adding modules, let and const, class syntax, arrow functions, and many other features. The specification subsequently moved to a yearly release cadence.
The failure of ES4 is instructive: evolving a ubiquitous language is as much a governance problem as an engineering problem. The platform has to improve without splitting implementations or abandoning billions of lines of existing code.
The rest of JavaScript’s history extends far beyond Eich. During the 2000s, Ajax popularized interfaces that could communicate with servers without reloading entire pages. Libraries and later frameworks helped structure increasingly complex applications.
From 2008 onward, engines such as V8 dramatically improved performance through just-in-time compilation and other optimization techniques. In 2009, Ryan Dahl created Node.js, using V8 to run JavaScript outside the browser. JavaScript expanded into servers, developer tooling, and environments that Netscape’s 1995 project had never targeted.
Eich did not create V8 or Node.js, nor did he personally design the many features later added to ECMAScript. His historical role is to have created the initial core and helped establish its standardization. The modern platform is a collective construction involving standards committees, engine teams, browser vendors, library authors, developers, and users.
Mozilla and the open Web
After AOL acquired Netscape, Eich became a major figure in the Mozilla project. He served in senior technical and executive roles at Mozilla. Firefox, launched in 2004, helped restore strong browser competition and advance open Web standards.
In 2014, Eich briefly became Mozilla’s CEO before resigning amid public controversy over a political donation he had made in 2008. The episode is part of his professional history but is separate from the technical assessment of his role in JavaScript.
In 2015, he co-founded Brave Software, maker of the Brave browser, which emphasizes tracking protection and a different approach to online advertising. The project continues Eich’s involvement with browsers, but it is distinct from JavaScript’s design and standardization.
Why Brendan Eich still matters to Web history
Eich’s lasting contribution is not that he single-handedly designed modern JavaScript. It is that he gave the browser a language at a decisive moment in the Web’s expansion-one accessible enough to spread immediately and expressive enough to outgrow the small scripts it was initially expected to handle.
Its influences help explain that adaptability: first-class functions, prototype-based objects, and dynamic behavior support very different programming styles. Its compromises also explain many of its difficulties. Both sides belong to the same history.
Most importantly, JavaScript shows how a language deployed on the Web quickly stops belonging to its creator. It becomes a collective contract among a specification, multiple engines, APIs, tools, and a vast body of existing software. Its success rests as much on that continuity as on its original design.
Timeline
- 1961: Brendan Eich is born in Pittsburgh.
- 1986: earns a master’s degree from the University of Illinois Urbana-Champaign.
- April 1995: joins Netscape.
- May 1995: builds the Mocha prototype in about ten days.
- 1995: Mocha becomes LiveScript and then JavaScript.
- 1996: Netscape submits the language to Ecma International.
- 1997: first edition of ECMA-262 is published.
- 1998: Eich helps establish the Mozilla project.
- 2004: Firefox launches.
- 2009: ECMAScript 5; Ryan Dahl launches Node.js.
- 2014: Eich briefly serves as Mozilla CEO.
- 2015: ECMAScript 2015 and the founding of Brave Software.
- Today: ECMAScript continues to evolve and JavaScript remains the universal native language of Web browsers.
Frequently asked questions
Did Brendan Eich really create JavaScript in ten days?
He created the first prototype, Mocha, in roughly ten days in May 1995. The language continued to change before release and then evolved for decades through standards and multiple implementations.
Is JavaScript a version of Java?
No. The name and some surface syntax create a misleading resemblance. JavaScript is dynamically typed and fundamentally prototype-based; Java was designed around a different model and execution environment.
What is the difference between JavaScript and ECMAScript?
ECMAScript is the standard specification defining the core language. JavaScript is the everyday name for implementations of that language. In a browser, JavaScript also works with Web APIs such as the DOM.
Why does JavaScript use prototypes?
Eich drew in part on the Self programming language. Objects can delegate property lookup to other objects. Modern class syntax does not replace this mechanism; it is built on top of it.
Did Brendan Eich create Node.js?
No. Ryan Dahl created Node.js in 2009 using the V8 engine. Its importance illustrates how far JavaScript expanded beyond its original role inside Web pages.
Why are JavaScript’s old quirks still there?
Because backward compatibility is a foundational Web constraint. Removing or changing old behavior could break sites that are still online, so the language usually evolves by adding better options while retaining much of its past.
