Brendan Eich created the first version of JavaScript, but the phrase “a language created in ten days” needs an essential qualification. In May 1995, Eich produced a prototype for Netscape in ten days. The language deployed, standardized, and used today is the result of three decades of corrections, compromises, and collective work.
That constrained origin nevertheless explains much of JavaScript. Netscape needed a language that was immediately accessible in the browser, distinct from Java but able to complement it. Eich had to combine ideas from several traditions behind syntax programmers would recognize.
Giving behavior to Web pages
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 Netscape, he worked on compilers and systems at Silicon Graphics.
In 1995, the Web consisted mainly of documents. A browser requested an HTML page and displayed it. Validating a form or changing content often meant contacting the server and loading another page.
Netscape, then a leading browser company, wanted a simple language for page authors. It was also working with Sun around Java, positioned for more structured applications. The future JavaScript needed to be lightweight, interpreted directly in the page, and usable without a compilation toolchain.
Ten days for a prototype, months for a language
Eich joined Netscape in April 1995. In May, he built the first prototype, Mocha. The ten-day deadline applied to that demonstration, not to a definitive language created in one pass.
It became LiveScript, then JavaScript at the end of 1995. The new name accompanied a commercial agreement with Sun and benefited from attention around Java. The languages remained different in design, types, and execution environment.
JavaScript presented a C-like surface: braces, expressions, and familiar control structures. Beneath it, Eich added first-class functions inspired partly by Scheme and a prototype object model reminiscent of Self.
A first-class function can be stored, passed to another function, or returned. This suits an event-driven environment: code associates functions with clicks, input, or completion of an operation. In the prototype model, an object delegates property lookup to another object. Later class syntax did not remove this foundation; it provides a more familiar way to use it.
Quick choices became durable contracts
The prototype had contradictory goals. Netscape wanted something approachable for page authors and familiar to C and Java programmers. Eich chose dynamic typing: a variable can hold different kinds of value, and conversions occur at runtime.
This made small scripts easier, but some implicit conversions are surprising. JavaScript also represented numbers less finely than Java, relying mainly on floating-point arithmetic. These were part of the initial compromise between learning speed, delivery time, and expressive power.
Eich also wrote the first engine, later SpiderMonkey. Designing syntax and interpreter together enabled rapid experiments but left little time to remove inconsistencies before publication. Once pages depend on behavior, changing it risks breaking sites. Details of the first implementation became compatibility obligations.
Unlike a language deployed in a controlled environment, JavaScript must account for programs scattered across the Web, often without authors available to update them.
A language caught in the browser war
JavaScript appeared in Netscape Navigator 2. Microsoft quickly produced a compatible implementation, JScript, for Internet Explorer. Browsers added proprietary objects and behaviors while the document model remained unstable.
The issue extended beyond the language. JavaScript defines values, functions, and operations; browsers supply APIs such as the document, events, and networking. Confusing those layers obscures the source of incompatibilities.
Netscape submitted the language to Ecma International in 1996. The first ECMA-262 edition appeared in 1997 under the name ECMAScript, making JavaScript the best-known implementation of a vendor-independent specification.
Standardization did not immediately resolve divergence. An ambitious ECMAScript 4 failed amid technical disagreements. The compromise produced ECMAScript 5 in 2009, followed by ECMAScript 2015 with modules, promises, class syntax, and new declarations. The specification now evolves annually.
Why JavaScript survived its flaws
Web compatibility is decisive. An old site should work in a new browser. Historical mistakes cannot always be removed; they are documented, avoided, or complemented by safer mechanisms.
This explains implicit conversions, two main values for missing data, historical scoping rules, and the peculiar behavior of this. It also explains the platform’s continuity.
In the 2000s, asynchronous requests enabled interfaces that updated without full reloads. From 2008, engines such as V8 used just-in-time compilation to accelerate execution. In 2009, Node.js used V8 outside the browser for servers and development tools.
Eich did not author those developments. His initial contribution enabled a platform that standards bodies, browser vendors, and communities then transformed.
From Mozilla to Brave
After AOL acquired Netscape, Eich helped develop Mozilla and became a leading technical executive. Firefox, launched in 2004, restored strong competition around an open browser and Web standards.
In 2014, Eich briefly became Mozilla’s chief executive before resigning amid public controversy over a political donation made in 2008. This belongs to his professional trajectory and should neither be erased nor confused with JavaScript’s technical history.
In 2015, he co-founded Brave Software, developing a browser centered on tracker blocking and an alternative advertising model. It continued his work in browsers but remained distinct from JavaScript and its standardization.
Why Brendan Eich still matters
Eich’s most durable contribution was giving the Web an embedded language when it might have remained primarily a document system. His choices enabled event-driven programming and dynamic pages with a low barrier to entry: a browser was enough to experiment.
JavaScript is now more rigorous, extensive, and performant than the 1995 prototype. Its history shows that a popular language is never only its creator’s plan. It becomes a contract among specifications, implementations, tools, existing programs, and users.
Timeline
1961: Brendan Eich is born in Pittsburgh.
1986: He earns a computer-science master’s at the University of Illinois.
April 1995: He joins Netscape.
May 1995: He builds the Mocha prototype in ten days.
September 1995: LiveScript is announced in Netscape Navigator.
December 1995: The JavaScript name is adopted.
1996: The language is submitted to Ecma International.
1997: The first ECMA-262 edition is published.
1998: Eich helps establish Mozilla.
2005: Ajax popularizes more dynamic Web applications.
2009: ECMAScript 5 appears and Node.js launches.
2015: ECMAScript 2015 appears and Brave Software is founded.
Today: ECMAScript evolves annually, and JavaScript remains the Web’s universal native language.
Frequently asked questions
Did Brendan Eich really create JavaScript in ten days?
He built the first prototype in ten days in May 1995. The commercial language evolved before release, and its specification and implementations have developed for decades.
Is JavaScript a version of Java?
No. Their names and some syntax are confusingly similar, but their type systems, object models, and environments differ. The JavaScript name mainly reflects 1995 marketing.
How do JavaScript and ECMAScript differ?
ECMAScript is the Ecma standard. JavaScript is the common name for compliant implementations, supplemented in browsers by Web APIs.
Why does JavaScript use prototypes?
Eich drew on Self to let objects delegate directly to other objects. Modern class syntax still rests on prototype chains.
Did Brendan Eich create Node.js?
No. Ryan Dahl created Node.js in 2009. It uses V8 to run JavaScript outside the browser.
Why are old language flaws not simply removed?
Changing them would break existing pages. Backward compatibility is fundamental to the Web, so standards often add better mechanisms without removing old ones.
Before JavaScript: a language engineer
Brendan Eich was born in Pittsburgh in 1961 and studied mathematics and computer science before earning a master’s degree at the University of Illinois Urbana-Champaign.
Before Netscape, he worked at companies including Silicon Graphics and MicroUnity. His work exposed him to compilers, programming languages, and lower-level systems. This matters because the familiar story of JavaScript’s rushed creation can otherwise suggest that an inexperienced programmer improvised a language from nothing.
When Eich joined Netscape in 1995, he already understood the practical compromises involved in language implementation.
1995: the Web needs a scripting language
The mid-1990s Web was very different from today’s application platform. Pages were primarily documents, while Netscape Navigator stood at the center of an intense browser competition.
Netscape wanted pages to become more interactive.
The company needed a language accessible enough to be embedded directly in HTML pages. Eich arrived with an interest in Scheme, but commercial and technical pressures favored syntax that looked familiar to programmers from the C and Java world.
That tension helps explain JavaScript’s unusual identity: C-like surface syntax, first-class functions, and a prototype-based object system.
The famous “ten days”
JavaScript’s origin is often compressed into one statement: Brendan Eich created it in ten days.
The claim is accurate in a narrow sense and misleading in a broader one.
In May 1995, Eich did assemble the first prototype of the language that became JavaScript in an extraordinarily short period. But modern JavaScript was obviously not fully designed during those ten days.
The prototype was a starting point. The language was corrected, standardized, expanded, and reinterpreted over more than three decades by a huge number of people.
The ten-day story explains historical constraints; it does not explain the entire language.
Mocha, LiveScript, and JavaScript
The language was initially called Mocha, then LiveScript.
By the end of 1995 it had become JavaScript.
The name appeared while Java was receiving enormous attention and created a confusion that persists: JavaScript is not a simplified edition of Java.
Java, associated with James Gosling, has a very different type system, architecture, and history.
The similarity of the names reflects the commercial context of the 1990s more than a direct technical relationship.
C-like syntax with ideas from Scheme and Self
JavaScript uses braces, operators, and many syntactic forms familiar to programmers coming from C-like languages.
Underneath that surface, however, important ideas come from elsewhere.
Functions are first-class values, reflecting functional traditions such as Scheme. Objects use prototype-based delegation, strongly influenced by Self, rather than a conventional class-centered model.
This combination explains why developers who approached JavaScript as “little Java” often misunderstood it.
First-class functions
A JavaScript function can be assigned to a variable, passed to another function, returned as a value, or created dynamically.
This choice became extraordinarily important.
Callbacks became fundamental to event-driven browser programming. Later, lexical closures, arrow functions, promises, and asynchronous patterns all built on a language in which functions had occupied a central role from the beginning.
One of the rushed prototype’s core decisions turned out to be remarkably durable.
Prototypes rather than classes
JavaScript’s original object model is based on prototype delegation.
An object can inherit behavior directly through another object’s prototype chain.
Developers trained in class-based object-oriented languages sometimes find the model unusual, but it offers considerable flexibility.
The class syntax added much later made some patterns more familiar without replacing the underlying prototype machinery.
Variables are not permanently bound to declared types in the way they are in many statically typed languages. Objects can be extended at runtime, and implicit conversions form part of the language’s historical behavior.
That flexibility makes rapid scripting convenient but also creates famous traps.
Much of JavaScript’s later evolution involves giving programmers safer and clearer patterns without breaking the enormous quantity of existing Web content that relies on old behavior.
Netscape versus Microsoft
When Microsoft developed Internet Explorer, it introduced its own compatible implementation called JScript.
The strategic danger was clear: if each browser evolved a different language, developers would need browser-specific pages and scripts.
The issue quickly became larger than Eich or Netscape.
For the Web to remain a shared platform, the language needed to move beyond the exclusive control of a single browser vendor.
ECMAScript: from browser feature to standard
Netscape submitted the language for standardization through Ecma International.
The resulting ECMAScript standard reached its first edition in 1997.
The distinction matters. ECMAScript is the standardized language specification; JavaScript is the familiar name for implementations and the broader ecosystem.
Standardization allowed multiple engines and browsers to target common semantics.
Eich remains a central historical figure, but JavaScript quickly stopped being “his” language in the sense that one person could determine its future.
Representatives from browser makers, technology companies, and the wider community develop proposals through a staged process.
Modern JavaScript governance demonstrates how a language born under extreme deadline pressure can evolve for decades without being replaced wholesale.
Compatibility shapes the language
JavaScript faces an unusually severe constraint: do not break the Web.
An old page can remain publicly accessible for decades. Browser vendors cannot simply remove every historical behavior that looks awkward today.
Some early quirks therefore become compatibility obligations.
This contrasts with Python, whose Python 2-to-3 transition accepted substantial incompatibility to correct old decisions. A language embedded in the public Web has much less freedom to perform an equivalent reset.
Difficult early years
During the late 1990s and early 2000s, JavaScript had a poor reputation among many professional developers.
Browser incompatibilities were common. Scripts were associated with superficial visual effects, pop-ups, and basic form validation.
The language was frequently treated as secondary.
Yet its decisive advantage already existed: it was available in virtually every Web browser.
Universal distribution would eventually matter as much as the language’s design qualities.
ECMAScript 4: an evolution that never arrived
JavaScript’s history also includes abandoned futures.
ECMAScript 4 proposed an ambitious transformation with many major features. Disagreement over complexity, compatibility, and direction ultimately prevented it from becoming the next standard in the intended form.
The failure is instructive.
Evolving a massively deployed language requires more than attractive technical ideas. It requires implementability, compatibility, and agreement among competing organizations.
ES5: consolidation
ECMAScript 5, published in 2009, became an important consolidation point.
It standardized and improved several parts of the language, including strict mode and useful library capabilities.
At the same time, the Web itself was changing.
Applications became richer, JavaScript engines became dramatically faster, and the browser was turning into a serious application platform.
AJAX changes expectations
During the 2000s, techniques grouped under the term AJAX demonstrated that Web pages could exchange data with servers without performing complete document reloads.
Applications such as Gmail and Google Maps helped change user expectations.
JavaScript was no longer merely adding small interactions to static pages.
It became the language orchestrating substantial applications inside the browser.
Eich did not create this later development, but it validated the long-term importance of having a programmable language universally present on the Web.
JavaScript engines become a technology race
As Web applications became more important, execution speed became strategic.
Browser vendors invested heavily in engines such as Mozilla’s SpiderMonkey, Google’s V8, and Apple’s JavaScriptCore.
Just-in-time compilation, dynamic optimization, and sophisticated runtime techniques transformed performance.
A language designed in 1995 for comparatively small scripts became capable of running applications far beyond what its first prototype was expected to handle.
Mozilla: from Netscape legacy to open community
After Netscape’s decline, the Mozilla project became increasingly important.
Eich helped establish the Mozilla Foundation and held major technical leadership roles within the organization.
Mozilla developed Firefox and advocated for an open Web in a period when dependence on a single browser platform was a serious concern.
Eich’s role therefore expanded beyond creating JavaScript: he became an important participant in browser technology and Web standards.
Firefox and browser competition
Firefox helped restore strong competition to the browser market during the 2000s.
That competition mattered for JavaScript.
Multiple engines had to implement shared standards, improve performance, and reduce incompatibilities.
A healthy Web language depends not only on a specification but on independent implementations that can be tested against the same content.
Node.js: JavaScript leaves the browser
In 2009 Ryan Dahl introduced Node.js, built around Google’s V8 engine.
The event dramatically expanded JavaScript’s territory.
Developers could now use the language conveniently for servers, command-line tools, build systems, and automation.
JavaScript increasingly became usable across much of the software stack.
This was not the purpose of Netscape’s 1995 prototype, but it illustrates how a widely distributed language can escape its original environment.
npm and ecosystem explosion
Node.js was accompanied by the growth of npm and an enormous package ecosystem.
That abundance accelerated development while introducing new problems: deep dependency trees, supply-chain security, fragmentation, and maintenance burdens.
Modern JavaScript history can no longer be understood through the language specification alone.
It includes package managers, transpilers, frameworks, bundlers, testing systems, and multiple runtimes.
ECMAScript 2015: a new scale of language
ECMAScript 2015, commonly called ES6, was one of the largest modernizations in JavaScript history.
let, const, arrow functions, classes, modules, promises, iterators, and many other features substantially changed everyday development.
The release demonstrates how far the language had traveled from its initial prototype.
Yet the evolution remained largely additive: new JavaScript still had to coexist with the old Web.
Classes do not remove prototypes
The class syntax makes JavaScript more familiar to developers coming from Java, C++, or C#.
It does not replace JavaScript’s fundamental prototype model.
Objects and methods produced through class syntax still rely on prototype chains.
That distinction matters historically: JavaScript could add a more familiar surface without erasing the conceptual model selected at its birth.
Promises and async/await
Browser programming is naturally event-driven and asynchronous.
Callbacks are powerful but can become difficult to organize when many operations depend on one another.
Promises, followed by async and await, provided more structured abstractions.
Their adoption illustrates modern language evolution: patterns developed through experience can be formalized and gradually integrated into the standard.
Brendan Eich and SpiderMonkey
Eich is also closely associated with SpiderMonkey, the original JavaScript engine created for Netscape and now developed in Mozilla’s ecosystem.
A programming language is more than a specification.
An implementation must parse code, execute it, manage memory, optimize hot paths, and connect the language to its environment.
SpiderMonkey reminds us that Eich was both a language designer and an implementation engineer.
The Web is larger than JavaScript
JavaScript works alongside other Web technologies.
HTML describes document structure, CSS handles presentation, and Web APIs provide access to the DOM, networking, storage, media, and many browser capabilities.
This distinction prevents a common misconception: not every object accessible from browser JavaScript is part of ECMAScript itself.
JavaScript succeeded partly because it sits at the programmable center of a much broader platform.
Compared with Java
The names encourage confusion, but the languages differ fundamentally.
Java was designed as a statically typed language centered on a virtual machine and a class-based object model.
JavaScript began as a dynamic browser scripting language with first-class functions and prototypes.
The languages later acquired some superficially similar features, but their architectures and ecosystems remain distinct.
Compared with Python
Python, created by Guido van Rossum, shares dynamic typing and an important role for functions and objects with JavaScript.
Their historical paths are very different.
Python grew as a general-purpose language deliberately shaped around readability. JavaScript first gained its unique position because it shipped in the browser and became standardized as the Web’s programming language.
One history demonstrates the power of a coherent language philosophy; the other demonstrates the extraordinary power of distribution and compatibility.
The difference reflects Self’s influence and reminds us that object-oriented programming has never had only one definition.
Later class syntax should therefore not obscure JavaScript’s historically distinctive model.
Eich did not create modern JavaScript alone
It is correct to say that Brendan Eich created JavaScript.
It would be wrong to say he designed modern JavaScript alone.
Today’s language is the product of decades of standards work, competing engines, TC39 proposals, libraries, frameworks, and feedback from millions of developers.
The biography is interesting precisely because it shows how an individual creation can become collective infrastructure beyond its creator’s control.
2014: controversy and departure from Mozilla
In 2014 Eich was appointed CEO of Mozilla Corporation.
His appointment triggered public controversy concerning a political donation he had made years earlier in support of California Proposition 8, which sought to ban same-sex marriage.
After a very short period as CEO, Eich resigned.
The episode belongs to his public biography but is separate from the technical evaluation of JavaScript. Including it provides a complete chronology without turning a history of his computing work into a political argument.
Brave Software
In 2015 Eich co-founded Brave Software.
The company developed the Brave browser with an emphasis on areas including privacy, blocking certain forms of tracking, and a different approach to online advertising.
The move returned Eich to the domain that had defined much of his career: the Web browser.
It also shows that two decades after JavaScript, he remained involved in questions about platforms, standards, privacy, and the economics of the Web.
An invention created under constraint
One of JavaScript’s most useful historical lessons is that durable inventions do not always emerge from ideal design conditions.
Eich had very little time. The language had to fit a commercial strategy, look sufficiently familiar, and function inside a browser competing for market share.
Those constraints produced compromises that programmers have criticized ever since.
They also produced an unusual combination of concepts that proved extraordinarily adaptable.
Mistakes can become contracts
When a language is young, a designer can change an awkward behavior.
When it runs on billions of Web pages, that behavior can become a contract even if nobody would design it the same way today.
This is one of JavaScript’s defining characteristics.
Backward compatibility explains why some quirks survive while new constructs are added to support clearer and safer styles.
The language often evolves through layers, not replacement.
JavaScript as global infrastructure
JavaScript today is not limited to browser scripts.
It runs in Web applications, servers, development tools, hybrid desktop applications, mobile environments, automation systems, and many embedded contexts.
That does not mean it is always the best language for every task.
It demonstrates the cumulative effect of three forces: universal browser availability, an open standard, and an enormous ecosystem.
Brendan Eich’s legacy
Brendan Eich’s legacy does not depend on the 1995 prototype being perfect.
It lies in creating, under extraordinary constraints, a core expressive enough to survive uses nobody could have predicted.
First-class functions, prototype-based objects, dynamic behavior, and browser integration provided a foundation that a worldwide community later transformed.
His story also demonstrates a broader truth about successful languages: eventually they outgrow their creators.
Modern JavaScript is less the work of one individual than a foundational layer of the Web maintained through standards, engines, organizations, and developers around the world.
Frequently asked questions
Who created JavaScript?
Brendan Eich created the first JavaScript prototype at Netscape in 1995. Modern JavaScript is the result of decades of subsequent collective evolution.
Was JavaScript really created in ten days?
The first prototype was assembled in roughly ten days in May 1995. The language used today evolved for more than thirty years afterward.
Why is it called JavaScript?
The name was adopted in the context of Java’s enormous visibility in 1995. JavaScript and Java are nevertheless distinct languages.
Which languages influenced JavaScript?
Its surface syntax borrows familiar forms from the C family, while first-class functions reflect influences such as Scheme and prototype-based objects were strongly influenced by Self.
Did Brendan Eich create ECMAScript?
He participated in the historical standardization effort, but ECMAScript is a collectively developed standard maintained through Ecma and TC39.
Does JavaScript still use prototypes despite class syntax?
Yes. JavaScript class syntax is built on the language’s prototype system.
Did Brendan Eich work at Mozilla?
Yes. He held major technical leadership roles at Mozilla and briefly became CEO in 2014.
What is SpiderMonkey?
SpiderMonkey is the JavaScript engine that originated at Netscape and is now associated with Mozilla Firefox.
What is Eich’s connection with Brave?
He co-founded Brave Software in 2015 and became its chief executive.
Why does Brendan Eich remain historically important?
Because the language whose first prototype he created became the universal programming language of the browser and a technology used far beyond client-side Web pages.
