This is the first post in the series that will talk about JavaScript. Let’s address everything. From the history of language, functions, objects, types, patterns, among other things. The intention is to make liking those who do not like it and to like even those who are already in love.

In this first post, I will give a brief history of the emergence of language.

Ready? So let’s go.


JavaScript was created in the 1990s by Brendan Eich at the service of Netscape. This decade was a period of revolution because the browsers were still static. The most popular browser at the time was the NCSA Mosaic.

NCSA Mosaic. The most popular browser of the 90’s.

Netscape was founded in 1994 to explore the Web that was emerging. Netscape Navigator was created. In a short time, this became the dominant browser in this decade. Many NCSA developers have been assigned to the Navigator project.

Netscape Navigator: Removed the crown from NCSA Mosaic.

Netscape came to the conclusion that the web would have to become more dynamic because the Navigator had to always make a request to the server for a response in the browser. In 1995, Netscape hired Brendan Eich to create a language that would provide that.

The initial proposal was the implementation of the Scheme language, based on purely functional LISP, in the Navigator. But Netscape had earlier projects in conjunction with Sun Microsystems to put its latest and most promising programming language, Java, into the Navigator. This raised an internal discussion of the reason for having two languages.

Obviously, the choice of a single language with Java-based syntax prevailed. The argument was that Scheme, for having a syntax and complexity characteristic of functional languages, would become unpopular (see code below). Netscape’s goal with the new language was just the opposite.

  (ironscheme clr)) 
;Define a function write-ln
(define (write-ln fmt . args)
  (clr-static-call System.Console WriteLine (clr-cast System.String fmt)
    (clr-cast System.Object[]
      (list->vector args)))) 
; And invoke it!
(write-ln "{0}" "Hello World!")

Even with “Javanese” syntax and other Java features (primitive values and objects), JavaScript was initially influenced by Scheme, and later by languages such as Self (prototypes), Perl, and Python (Strings, arrays and regular expressions).

To defend JavaScript against other proposals, a prototype was created by Eich in ten days in May 1995. Marc Andreesen named the Mocha prototype. The language name changed again to LiveScript because of patents and because several products were taking “Live” as a suffix.

Brendan Eich: The creator of JavaScript and former CEO of Mozilla.

At the end of November 1995, Navigator version 2.0B3 came out with the “ten day” version without much change.

In early December 1995, Java was at its peak and the language was renamed to JavaScript.

The ECMA regulations

After JavaScript was created, Microsoft created an identical language in August 1996 to be used in Internet Explorer 3. To counter Microsoft’s ambition, Netscape decided to standardize the language through the organization ECMA International, a company that specialized Standards.

Work on the ECMA-262 standard began in November 1996. The JavaScript name was already patented by Sun Microsystems (now Oracle) and could not be used. Therefore, the name composed of ECMA and JavaScript was used, resulting in ECMAScript.

Even with this name, to this day the language is affectionately known by JavaScript. ECMAScript is only used to refer to language versions.

ECMA-262 is maintained by Technical Committee 39 (TC39). This committee is composed of experts from major companies such as Microsoft, Mozilla, and Google. Among the members of the committee is, of course, Brendan Eich. Discussions are opened through email lists and physical meetings always have invitations to experts interested in maintaining the regulations.

Meeting of the TC39 in July 2015. TC39 meeting in July 2015. ( Source )

Version history

ECMAScript 1 (June 1997)

The first version (“ten days”).

ECMAScript 2 (August 1998)

Editorial changes to align the ECMA-262 with the ISO / IEC 16262 standard.

ECMAScript 3 (December 1999)

It was in this version that JavaScript won important implementations such as do-while, regular expressions, new methods for the string object, exception handling, among other things.

ECMAScript 4 (abandoned in July 2008)

ECMAScript 4 was developed to be the new version of JavaScript with a prototype written in ML. However, the TC39 rejected the prototype because of its new implementations. The number of new features would make the migration from ECMAScript 3 to 4 very disruptive.

To avoid deadlocks, the TC39 met and entered into an agreement with the developers in July 2008. The agreement took into consideration 4 points:

  1. Develop an incremental update of ECMAScript 3 (which has become ECMAScript 5);
  2. Develop a version that does less than ECMAScript 4, but more than the incremental update of ECMAScript 3. The name of this version is Harmony and it will be split into ECMAScript 6 and ECMAScript 7;
  3. The features of ECMAScript 4 would be discarded;
  4. Other ideas should be developed with full consensus of the TC39.

ECMAScript 5 (December 2009)

Strict (‘use strict’), getters and setters, new array methods, JSON support among other things. This is the incremental update agreed upon at closing of ECMAScript 4.

ECMAScript 5.1 (June 2011)

Editorial changes to align the ECMA-262 with the third version of the ISO / IEC 16262: 2011 standard

ECMAScript 6 (June 2015)

Also known as ECMAScript 2015, it is the first phase of the Harmony version. It includes much shorter syntax and functions like arrow functions, binary data, typed arrays, collections (maps, sets, and weak maps), promises, numerical improvements and math, reflection, and proxies.

ECMAScript 7 (June 2016)

Also known as ECMAScript 2016, it is the last phase of the Harmony version. Includes features such as exponential operators and the Array.prototype.includes method.

Some browsers still do not fully support version 6 and 7 of ECMAScript. However, it is possible to transpile to ECMAScript 5 through libraries like Babel or Polyfills.


I highly recommend the O’Reilly Speaking JavaScript Book. In addition to the detailed history, it is a true JavaScript manual.


Understanding how the language was created helps to understand why it is this way today and how it will evolve. JavaScript, thanks to the collaboration of large companies and experts, is a real open language.

I used to think, before knowing the story, that JavaScript had undergone a rebirth with Google’s V8 interpreter. But analyzing the story, it never died. It has always been maintained. The V8 was just one of the steps to make it more and more promising and popular.

What did you think of the story? How do you think language will continue to evolve?

Share in the comments.