Introduction, Uses, History and Evolution of JavaScript
Tags: javascript, beginners, webdev, programming
Published: 2023-05-20 04:30:52

## Overview

JavaScript is a programming language that was created by Brendan Eich in 1995 for adding interactivity to web pages. Initially it was called LiveScript, but later it was renamed to JavaScript. 

It runs in the browser and on the server. JavaScript is a dynamic, weakly typed, and interpreted programming language. It is a multi-paradigm language, which means that it supports different programming styles like object-oriented, functional, and imperative programming. 

Before jumping to the next thing about JS, let's see what programming language is

## Programming Language

A programming language is a set of rules, symbols, and syntax that is used to communicate instructions to a computer. It is a way for humans to write programs that the computer can execute. There are many programming languages, each with its own set of rules and syntax. Some examples of programming languages include:

| Language                                                                | Creator                 | Year |
|-------------------------------------------------------------------------|-------------------------|------|
| [C](<https://en.wikipedia.org/wiki/C_(programming_language)>)           | Dennis Ritchie          | 1972 |
| [C++](<https://en.wikipedia.org/wiki/C%2B%2B>)                          | Bjarne Stroustrup       | 1983 |
| [Java](<https://en.wikipedia.org/wiki/Java_(programming_language)>)     | James Gosling           | 1995 |
| [Python](<https://en.wikipedia.org/wiki/Python_(programming_language)>) | Guido van Rossum        | 1991 |
| [JavaScript](<https://en.wikipedia.org/wiki/JavaScript>)                | Brendan Eich            | 1995 |
| [PHP](<https://en.wikipedia.org/wiki/PHP>)                              | Rasmus Lerdorf          | 1995 |
| [Ruby](<https://en.wikipedia.org/wiki/Ruby_(programming_language)>)     | Yukihiro Matsumoto      | 1995 |
| [C#](<https://en.wikipedia.org/wiki/C_Sharp_(programming_language)>)    | Microsoft               | 2000 |
| [Scala](<https://en.wikipedia.org/wiki/Scala_(programming_language)>)   | Martin Odersky          | 2003 |
| [Go](<https://en.wikipedia.org/wiki/Go_(programming_language)>)         | Google                  | 2009 |
| [Rust](<https://en.wikipedia.org/wiki/Rust_(programming_language)>)     | Mozilla                 | 2010 |
| [Dart](<https://en.wikipedia.org/wiki/Dart_(programming_language)>)     | Google                  | 2011 |
| [Kotlin](<https://en.wikipedia.org/wiki/Kotlin_(programming_language)>) | JetBrains               | 2011 |
| [TypeScript](<https://en.wikipedia.org/wiki/TypeScript>)                | Microsoft               | 2012 |
| [Swift](<https://en.wikipedia.org/wiki/Swift_(programming_language)>)   | Chris Lattner and Apple | 2014 |

## Uses of JavaScript

JavaScript is a programming language that is commonly used in software development in several contexts. Here are some examples of how JavaScript is used in different areas of software development like frontend, backend, mobile, desktop, game development, etc. 

## History and evolution of JavaScript

JavaScript is a programming language that was created by Brendan Eich in 1995 for adding interactivity to web pages. Initially it was called LiveScript, but later it was renamed to JavaScript.  **ECMAScript** (shortly **ES**) is the official name of the JavaScript standard. It is maintained by the European Computer Manufacturers Association (ECMA) and is the standard that all JavaScript engines must follow.

JavaScript has undergone several versions over the years. The most widely used versions are:

- [ES1 - also known as ECMAScript 1, released in 1997](#es1---1997)
- [ES2 - 1998](#es2---1998)
- [ES3 - 1999](#es3---1999)
- [ES5 - 2009](#es5---2009)
- [ES6 - 2015](#es6---2015)
- [ES7 - 2016](#es7---2016)
- [ES8 - 2017](#es8---2017)
- [ES9 - 2018](#es9---2018)
- [ES10 - 2019](#es10---2019)
- [ES11 - 2020](#es11---2020)
- [ES12 - 2021](#es12---2021)

Let's see them in details.

### ES1 - 1997

Introduced the basic syntax of the language, including variables, operators, and control statements.

### ES2 - 1998

Introduced the `with` statement, which allows you to create a new scope for a block of code. It also introduced the `for-in` loop, which allows you to iterate over the properties of an object.

### ES3 - 1999

Introduced regular expressions, better string handling, new control statements, and try-catch exception handling. It also improved the handling of errors and introduced the strict mode, which helps to prevent some common JavaScript errors.

### ES5 - 2009

Made improvements to the language such as better support for arrays, new methods for working with strings and objects, and the ability to create more efficient code using strict mode. It also introduced new methods to help prevent and fix common coding mistakes.

### ES6 - 2015

ES6 is a significant update to the language, introducing many new features and improvements. Some notable features include:

- `let` and `const` for variable declarations - to declare variables that are block-scoped
- arrow functions - a shorter syntax for writing functions i.e. `const add = (a, b) => a + b`
- template literals - backticks (``) for string interpolation and multi-line strings
- classes and inheritance - a way to create objects and classes
- destructuring assignment - to unpack values from arrays and objects into distinct variables
- default function parameters - to set default values for function parameters
- `Promises` for handling asynchronous code - a more readable way to handle asynchronous code
- and many more improvements and additions to the language

### ES7 - 2016

ES7 introduced several new features, including:

- `Array.prototype.includes()` - method to check if an array contains a value or not i.e. `array.includes(value)` returns `true` if the array contains the value, and `false` if it does not
- Exponentiation operator (`**`) - to calculate the power of a number (e.g. `2 ** 3` is `8`)
- and `async`/`await` - another way to handle asynchronous code
- and many more improvements and additions to the language

### ES8 - 2017

It includes:

- `Object.values()` and `Object.entries()` - methods to get the values and entries of an object as an array (e.g. `Object.values({ name: 'John', age: 30 })` returns `['John', 30]`)
- String padding - to add padding to a string using the `padStart()` and `padEnd()` methods (e.g. `'hello'.padStart(10)` returns `'     hello'`)
- `Object.getOwnPropertyDescriptors()` - method to get the descriptors of an object
- `async` functions - asynchronous functions that return a `Promise` and can use the `await` keyword
- and more improvements and additions to the language

### ES9 - 2018

It introduced:

- Asynchronous iteration - to iterate over asynchronous data i.e. `for await (const value of asyncIterable) { ... }`
- rest/spread properties for objects - to copy objects and merge objects using the spread operator (`...`) i.e. `{ ...obj1, ...obj2 }`
- `promise.finally()` - to execute code after a `Promise` is settled (either fulfilled or rejected)
- template literals improvements - to use raw strings and to tag template literals
- and many others

### ES10 - 2019

It included:

- `Array.flat()` and `Array.flatMap()` - to flatten arrays and to flatten arrays and map them at the same time
- `Object.fromEntries()` - to convert an array of key-value pairs into an object i.e. `Object.fromEntries([['foo', 1], ['bar', 2]])` // `{foo: 1, bar: 2}`
- `String.trimStart()` and `String.trimEnd()` - to trim whitespace from the beginning and end of a string
- and others

### ES11 - 2020

It introduced:

- Dynamic `import()` - to import modules dynamically (i.e. at runtime)
- globalThis - to get the global object i.e. `globalThis` is the same as `window` in the browser and `global` in Node.js
- Nullish coalescing operator (`??`) - to return the right-hand side operand when the left-hand side operand is `null` or `undefined`
- `BigInt` - to represent integers larger than 2^53 - 1 which is the largest number JavaScript can reliably represent with the Number primitive and represented by the Number.MAX_SAFE_INTEGER constant
- and others

### ES12 - 2021

It includes:

- Logical assignment operators - to assign values to variables based on a condition (e.g. `x ||= y` is the same as `x = x || y`)
- Optional chaining operator (`?.`) - to access properties of nested objects without having to check if the parent object exists or not
- Nullish coalescing operator (`??`) - to return the right-hand side operand when the left-hand side operand is `null` or `undefined`
- String.prototype.matchAll() - to get all matches of a regular expression in a string as an iterator of `RegExpMatchArray` objects (i.e. `string.matchAll(/foo/g)`)
- JSON superset - to allow trailing commas in JSON objects and arrays and to allow single quotes in JSON strings (i.e. `{"foo": "bar",}` and `{"foo": 'bar'}` are valid JSON)
- and others


It's worth noting that not all browsers or JavaScript engines support the latest version of ECMAScript, so it's important to keep that in mind when developing applications that need to run on multiple platforms, because some features may not be supported on all browsers, like Internet Explorer.