
https://youtu.be/EelD6EFWgcs

JavaScript's prototypal system is inspired by the language Self. Now, Self was the first one to
implement it. Lua, ActionScript, JScript, Cecil and many other languages exist that implement this
pattern.

In prototype system, there are no classes. Yes, JS has no classes and ES6 classes is just a
syntactic sugar, internally JS does prototype-based wiring for you.

Class-based languages are based on a deep-rooted duality of Classes & Object Instances. For instance,
if we create an object of the class Vehicle, such as Red Car, and send it a message to deliver super
heavy materials, it is not feasible because Red Car is not equipped for that and it is something
that's wired in Vehicle class. This highlights the importance of subclassing, which enables creating
specialized classes, such as Sports Car and Truck, with their own unique capabilities.

However, predicting the future qualities of objects and classes is challenging, and systems can
become rigid when the initial design does not anticipate future changes. And this
was one of the motivation to create prototype feature, as such use cases occur in real world development
all the time.

## Object

Objects are much more than just maps in JavaScript. They are not just a collection of key value
pair. They are very generic in nature for instance, you can link them to create the features of
inheritance with no classes at all.


Inheritance in JavaScript


https://youtu.be/zoz_Ih9-y_0

Implicit binding applies when we use a function and invoke it as a method of an object. In that
case, the `this` keyword points to the object on which the method was invoked. In the following
examples you will notice that the invocation of `getName` was done using the object `person` and
that's what made the `this` keyword point to the `person` object.

```js
var person = {
  firstName: 'meher',
  getName: function () {
    console.log(this.firstName)
  },
}

person.getName() // outputs meher
```

## Function Outside the Method

Furthermore, it doesn't matter if the function was defined inside or outside the object. Take a look
at the example below, the function's definition location is inconsequential. However, because the
function is once again invoked using the person object, the this keyword comprehends the context and
refers to the person object.

```js
function getName() {
  console.log(this.firstName)
}

var person = {
  firstName: 'meher',
  getName,
}

person.getName() // outputs meher
```

As the function location doesn't matter, we can use this to our advantage and create a reusable
function that can run on different objects and return different results. For example, if `employee`
object and `person` object both can access the `firstName` function.

## When Implicit Binding Fails

If you store the function reference in a variable and then invoke the function later. **The implicit
binding is lost.**

```js
var person = {
  firstName: 'meher',
  getName: function () {
    console.log(this.firstName)
  },
}

var fn = person.getName

// isn't this invocation similar to default binding,
// this returns 'undefined' as the window object has no firstName
fn()
```

## Callbacks

There is a rule that says, this keyword points to whatever is on the left side of the method. Unfortunately, it doesn't work with callbacks. Here's an example:

```js
function getName() {
  console.log(this.firstName)
}

var person = {
  firstName: 'meher',
  getName,
}

function displayFirstName(cb) {
  cb()
}
// because again the cb() invocation follows the default binding rule and
// hence this keyword points again to window
displayFirstName(person.getName)
```

And this can even happen when we use a native method like setTimeout. So when it comes to passing methods, we should always give a thought about how the actual invocation will happen and how will it impact the value of `this` keyword.

```js
function getName() {
  console.log(this.firstName)
}

var person = {
  firstName: 'meher',
  getName,
}

setTimeout(person.getName, 1000)

// An implementation similar to this could be found in a library or native API:

function setTimeout(fn, delay) {
  fn()
}
```

So that's second way the value of `this` keyword can have a different value. Now, let's look at the
[next part](/explicit-binding-this-keyword) which is
[**Explicit Binding**](/explicit-binding-this-keyword)


Implicit Binding - THIS Keyword


JavaScript, or JS, is a web programming language alongside HTML and CSS. It is widely used, with 98% of websites incorporating it for webpage behavior. JavaScript is a high-level language with dynamic typing and supports multiple programming styles. It has APIs for various tasks and works with the Document Object Model (DOM). While it lacks built-in I/O, web browsers and runtime systems provide JavaScript APIs for that.

JavaScript engines are now used in servers and applications, with Node.js being the most popular runtime system. Despite similar names, Java and JavaScript have distinct designs and differ significantly.

## Influences

- C and C++ influenced JavaScript's syntax.
- Self inspired JavaScript's prototype-based object-oriented programming model.
- Lisp and Scheme influenced JavaScript's functional programming concepts.
- Perl influenced JavaScript's regular expression syntax.
- Smalltalk influenced JavaScript's event-driven programming model.
- Haskell influenced JavaScript's built-in functional methods.

## EcmaScript vs JavaScript

ECMAScript is the standardized scripting language specification, defining the syntax, semantics, and behavior. JavaScript is the most widely used implementation of ECMAScript, known for web development. It extends the specification with browser-specific features like DOM manipulation and event handling.

In simpler terms, ECMAScript is the standard, while JavaScript is its popular implementation primarily used in web browsers. Other implementations include JScript and ActionScript.

## Creation

In the early days of the web, Mosaic was a popular browser that led to the founding of Netscape. Netscape Navigator, a more advanced browser, was released in 1994 and gained widespread usage. To overcome the limitation of static web pages, Netscape sought to add a scripting language. They considered Java and Scheme but ultimately decided on a new language with Java-like syntax.

Initially named LiveScript, it was later rebranded as JavaScript upon its official release in December 1995. The choice of the name JavaScript caused confusion, as it was unrelated to Java and seen as a marketing tactic during the dot-com boom.

## Browser Wars

In the browser war between Microsoft and Netscape, Microsoft introduced Internet Explorer in 1995 and developed its own JavaScript interpreter called JScript. JScript was released in 1996 with support for CSS and HTML extensions, but it differed significantly from Netscape's implementation, causing compatibility issues for developers.

In 1996, Netscape submitted JavaScript to Ecma International to establish a standardized specification, leading to the release of the first ECMAScript language specification in 1997. Microsoft's dominance in the browser market made JScript the de facto standard for client-side scripting. While initially involved in the standards process, Microsoft eventually withdrew, leading to the shelving of ECMAScript 4.

## Growth

In the early 2000s, Internet Explorer dominated the browser market, causing stagnation in client-side scripting. However, in 2004, Mozilla's release of Firefox challenged Internet Explorer's dominance and gained significant market share. Mozilla joined ECMA International in 2005 and collaborated with Macromedia (later Adobe Systems) to standardize ActionScript 3 as the new ECMAScript 4.

Despite efforts, ECMAScript 4 did not materialize without Microsoft's cooperation. Meanwhile, open-source communities thrived, with the introduction of Ajax and JavaScript libraries like jQuery, Prototype, Dojo Toolkit, and MooTools. Google's Chrome browser, featuring the faster V8 JavaScript engine with just-in-time compilation, prompted other browser vendors to improve their engines. In 2009, a conference in Oslo brought various parties together, resulting in the release of ECMAScript 5 standard in December 2009.

## Dominanace

ECMAScript 6 was published in 2015, marking the culmination of years of ambitious work and introducing numerous additions and refinements. The introduction of Node.js in 2009 by Ryan Dahl expanded JavaScript's usage beyond web browsers, providing a standalone runtime system. Node.js, powered by the V8 engine, an event loop, and I/O APIs, gained popularity among millions of developers, with npm becoming the world's largest package manager.

The ECMAScript draft specification is now openly maintained on GitHub, with regular annual snapshots and a comprehensive proposal process for potential language revisions. The JavaScript ecosystem includes libraries, frameworks, established practices, and extensive usage outside of web browsers. Transpilers have emerged to facilitate development, particularly for single-page applications and JavaScript-intensive websites.
