JavaScript History
Why should you care about JavaScript History?
JavaScript's history explains its name, its relationship to ECMAScript, and why browser compatibility matters.
JavaScript began as a browser scripting language and later became a standardized language used in many environments.
This page traces the language's origins, its standard, and the reasons browser compatibility still matters.
The language changed names while it was being created. It was first called Mocha, then LiveScript, and finally JavaScript.
The name was partly a marketing decision because Java was popular at the time. JavaScript and Java are separate languages.
Remember: JavaScript is not a version of Java. The similar names do not mean that the languages are the same.
As JavaScript became popular, Netscape was not the only browser company using it. Microsoft added its own implementation to Internet Explorer. Different browsers sometimes interpreted the same code differently.
This period is often called the browser wars. For developers, it could mean writing one version of a page for one browser and another version for a different browser.
The web needed a shared set of rules so browser teams could build compatible implementations. Netscape submitted JavaScript to the standards organization ECMA, which led to the ECMAScript standard.
Why this matters: Standardization did not make every browser identical, but it gave them a common language foundation.
Picture this: it's 1995, and websites are mostly static documents. Netscape, the popular browser company at the time, wanted to change that and make web pages interactive. They hired a programmer named Brendan Eich to create a scripting language. In an impressive 10 days, he built the first version of JavaScript.
The first version was a small browser scripting language. JavaScript later grew as standards and new uses emerged.
As other browsers adopted JavaScript, developers needed shared rules for compatible implementations.
In short: Netscape developed JavaScript in 1995 to make web pages interactive.
- JavaScript debuts
Netscape introduces the language in Navigator.
- First standard
Ecma publishes the first edition of ECMA-262.
- Chrome and V8
Google launches Chrome with the V8 JavaScript engine.
- ES5 and Node.js
ES5 is published. Node.js brings V8 to a server-side runtime.
- ES2015
Also called ES6, it adds modules, classes, and promises.
- Annual editions
ECMAScript editions take the year as their name.
JavaScript is the programming language developers write and use in browsers, servers, and other environments.
ECMAScript is the specification, or rulebook, that describes how the core language should work. It defines things such as syntax, values, functions, and language features.
TC39 is the committee that develops and maintains the ECMAScript standard. Ecma International is the standards organization that publishes it.
A simple way to remember the relationship is:
- TC39 develops the ECMAScript standard.
- Ecma International publishes the specification.
- JavaScript engines implement the standard.
- Browsers provide the environment where your JavaScript runs.
Why this matters: A shared rulebook helps different JavaScript implementations agree on the core language, even though browser support for newer features can still vary.
What Is ECMAScript?
ECMAScript defines the core language. JavaScript engines implement that specification, while browsers and other hosts provide additional APIs and a runtime environment.
ECMAScript is maintained through two main official documents:
- ECMA-262 - The main ECMAScript language specification defines syntax, types, and built-in behavior. JavaScript engine implementers use it as a common reference.
- ISO/IEC 22275:2018 defines the ECMAScript Specification Suite as an ISO/IEC International Standard. It is not a yearly edition of ECMA-262.
JavaScript Versions: The Big Picture
The key milestones are ES3, the abandoned ES4, ES5, and the major ES2015 update. Since then, new editions have generally been published annually.
| Version | Year | Why it matters |
|---|---|---|
| ES3 | 1999 | Established important early language features. |
| ES5 | 2009 | Added strict mode, JSON, and useful array methods. |
| ES6 / ES2015 | 2015 | Major modernization with features developers still use today. |
| ES2016 onward | Generally annual | Incremental updates; ES2026 is the latest edition. |
Published ECMAScript editions
| Year | Edition |
|---|---|
| 1997 | ES1 |
| 1998 | ES2 |
| 1999 | ES3 |
| 2009 | ES5 |
| 2011 | ES5.1 |
| 2015 | ES2015 (ES6) |
| 2016 | ES2016 |
| 2017 | ES2017 |
| 2018 | ES2018 |
| Year | Edition |
|---|---|
| 2019 | ES2019 |
| 2020 | ES2020 |
| 2021 | ES2021 |
| 2022 | ES2022 |
| 2023 | ES2023 |
| 2024 | ES2024 |
| 2025 | ES2025 |
| 2026 | ES2026 |
The proposed fourth edition was never published.
Early editions were released at irregular intervals. Since ES2016, editions have generally been published each year.
- ES1 (1997), ES2 (1998), ES3 (1999) - These early versions established the basics. ES3 added regular expressions and error handling, which were huge at the time.
- ES4 - Abandoned. The community couldn't agree on the direction, so this version never happened.
- ES5 (2009) - After a long gap, ES5 brought strict mode (which catches common mistakes), JSON support, and useful array methods. This version gave JavaScript a stability boost.
- ES6 / ECMAScript 2015 - ES6 introduced features such as arrow functions, template literals, block-scoped let and const declarations, and class syntax built on JavaScript's prototype system. It is often treated as the start of modern JavaScript, though the language continues to evolve. Important naming note: ES6 is also called ES2015. Later editions use year-based names, such as ES2016, ES2017, and ES2018. Both naming styles remain common online.
-
ECMAScript 2016 onwards - Yearly updates - New editions have generally been published annually since 2016. Examples of features follow:
- 2016: Array.includes() for checking if an element exists in an array
- 2017: async/await syntax, plus Object.values() and Object.entries()
- 2018: Object rest and spread syntax; array rest and spread were standardized earlier.
- 2020: Optional chaining (?.) and nullish coalescing (??) for safer property access
- 2021: Promise.any() and String replaceAll() method
- 2022: Class fields and private methods
- 2023: Array methods like findLast() and toSorted() for convenient data manipulation
- 2024-2026: Object.groupBy() and Map.groupBy() (2024); iterator helpers and Set methods (2025); further additions (2026). See the current specification for details.
Why Do Developers Talk About ES5 and ES6?
ES5 and ES6 mark major stages in JavaScript's development. ES6 / ES2015 introduced features such as let and const, arrow functions, template literals, and class syntax. These features remain common in modern code.
The language continues to evolve, but you can learn its core features without memorizing edition numbers.
Node.js (2009) made server-side JavaScript practical and expanded where the language could run. It complements rather than replaces browser JavaScript.
Pro tip for beginners: Some older features, such as var remains relevant when reading older code. Modern code generally prefers let and const because they are block-scoped. You will learn the differences later.
Major browsers use JavaScript engines that parse and execute code according to ECMAScript. Browsers can share engines: Chrome and Edge use V8, Firefox uses SpiderMonkey, and Safari uses JavaScriptCore. Engines may add support for new language features at different times.
JavaScript engines aim to follow the same ECMAScript standard, but new language features may arrive at different times. Browser APIs can also vary, so check support for the browsers you target. Feature detection and polyfills can help when needed.
A Simple Compatibility Example
Suppose a new JavaScript feature is released. A newer browser may support it, while an older browser may not understand it. Developers can check whether a feature exists, transform newer code into an older form with a transpiler, or provide a polyfill that adds a missing behavior. These tools help support more browsers, but an older browser cannot automatically understand brand-new syntax by itself.
Two compatibility concepts you'll encounter:
- Backward compatibility - Newer engines aim to preserve the behavior of older JavaScript code, though browser APIs and surrounding services can still change.
- Forward compatibility - A system is designed to tolerate some future changes. Older browsers still need transformed code or a fallback to handle newer JavaScript syntax.
These examples show how compatibility depends on which system is older and whether new additions are optional:
| Topic | Backward Compatible | Forward Compatible |
|---|---|---|
| Browsers | Newer engines aim to run code written for older ECMAScript editions. | Older browsers cannot parse new syntax unless code is transformed or a fallback is used. |
| File Formats | Newer software can read older file formats when the format remains supported. | Older software can ignore unknown optional fields if the format allows it. |
| APIs | Newer API versions may preserve older endpoints or behavior. | A client can tolerate added response fields if it ignores unknown fields. |
| Hardware | Newer hardware can support software designed for older hardware when compatible. | Older hardware cannot use unsupported features; software needs fallbacks for those devices. |
| Software | Newer software may preserve compatibility with older versions or data. | Older software can tolerate additions only when designed to handle them. |
You do not need to memorize every ECMAScript version or every yearly feature. For now, remember:
- JavaScript was created in 1995 at Netscape by Brendan Eich. It was originally called Mocha, then LiveScript.
- ECMAScript is the specification behind the core language. TC39 develops it, and Ecma International publishes it.
- ES6 / ECMAScript 2015 marked a major modernization. New editions have generally followed an annual schedule since 2016, through ES2026.
- Node.js (released in 2009) made server-side JavaScript practical.
- Browsers use engines that may support new language features at different times, so check compatibility for your target browsers.
- Backward compatibility means newer systems can continue to work with older code or data.
- Forward compatibility means a system is designed to handle certain future changes; old browsers still need transformed code or a fallback for new JavaScript features.
What's next? You now know where JavaScript came from and how it evolved. Next, let's set up your coding environment so you can start writing JavaScript yourself in the next tutorial.
- Tell us about the history of JavaScript.
- What is ECMAScript and How is it related to JavaScript?
- What are the different versions of JavaScript?
- What is ES5 and ES6?
- Describe the significance of standardization for JavaScript and how ECMA helps in this process.
- Tell about challenges arise in ensuring JavaScript compatibility across different browsers and devices?
- What are the common techniques or tools used to handle JavaScript compatibility issues between various browsers and versions.
- Explain the significance of polyfills and transpilers in dealing with JavaScript compatibility concerns. Provide examples of situations where each would be beneficial.
- How does feature detection differ from browser detection in managing JavaScript compatibility? When would you use each approach?
- What is forward compatibility?
- What is backward compatibility?
- What is ECMA-262 specification ?
- What is ISO/IEC 22275 standard ?