I feel that most of the javascript frameworks were built to solve specific problems which evolve continuously along with core language itself keeping the language relevant in fast evolving technical world. Inclusion of many new features in es6 and es7 like destructing and spread operator have greatly increased our ease of development. Same goes for all major frameworks built over it like inclusion of async await in nodejs core, addition of many new features/components in reactjs/reactnative(still have not finished watching complete ReactConf 2017 yet ;P), complete redesign of angular 2 using typescript...

My favorite thing about js is that it is itself a good language but it is because of contributions of tons of developers like Ryan Dahl(creator of nodejs) and major companies like Microsoft,Google Facebook,Linux Foundation among others to its frameworks we now can use the language to solve many real world problems and extend the language if some problems requires new set of constructs because of its wide opensource nature.

It works on many platforms and environments, with prototypal and functional paradigms, easy to learn, etc. My main language since '98 :)

If you want to start as a developer, choose Javascript. A basic knowledge is enough to start building websites / get an entry level developer job, and as you gain more and more experience and you look out at frameworks like React, Vue, Angular etc.

React

Like all three of the web trinity - I like that it's really very easy to get started: create an HTML file, open it in a browser, voila! You can write CSS and JS. That's even more powerful when you realise how widespread javascript is (I won't say "popular" per se ;)).

My favorite thing would be this:

Function instanceof Object //true

Object instanceof Function //true

Go ahead and try it out in a browser or in Node.

This works because functions are objects as well in JavaScript, so you can attach other properties to a function, which is how JQuery works. It also works the other way another, because Object is actually a function. In the old days, in order to create a new empty object, you would do:

new Object() //Same as {}

You could also drop the new and still get a object.

I like that because JavaScript runs in the browser, you can also write it in the browser and run it everywhere.

One day on the subway (cut off from the internet) I realized I wanted to see what was 'inside' document or window to see what I could use. I wrote something small on my phone like:

var s = []; for (i in document) { s.push(i) }; alert(s)

And POOF! Before my eyes I saw everything that was inside document:

I repeated the same thing for window, and realized: You can dynamically explore JavaScript with JavaScript.

That demo eventually turned into http://staticresource.com/explore.html which you can navigate by clicking on the page.

The more I write JavaScript, the more I love how simple, flexible, and ubiquitous it is. There's hardly ever a moment when I don't have either a computer or mobile device with a browser nearby, so there's hardly ever a moment I think of something to try that I don't have the ability to test it right away!

JavaScript is exemplary of the fact that being at the right place at the right time can take you to great heights. Even with obvious design flaws — like this, for instance — it has went on to become, in Jeff Atwood's words, the world's most ubiquitous computing runtime, and that is my favorite thing about JavaScript.

Speaking in terms of the language construct, closures have a special place in the list of all of my favourite things.

I knew about the concept of closures from the time I spent with Python; but when I happened at them again, while going through Crockford's book ... I can't quite zero in on the reason; the simplicity of the following example, had won my heart.

var myObject = (function () {
    var value = 0;

    return {
        increment: function (inc) {
            value += typeof inc === 'number' ? inc : 1;
        },
        getValue: function () {
            return value;
        }
    };
}());

Whenever I see non-blocking code execution, it blows my mind, how can it be possible? Event-loop is the backbone of JS, and it's the reason behind my love for JS.

Asynchronous nature is the most lovable part of JS.

Actually two things:

• Nearly everything is a (mostly) mutable object
• You can do anything with JavaScript (program Arduino, create a server, build Apps,...)

(Its mother told it, it could be anything, so it became everything /jk)

They are also reasons why I hate JS :D

I love that it's taking over everything.

Learn once and write code in JavaScript every where.

1. Mobile apps
2. Web apps
3. Backend code
4. Whatnot?

😃

Recently I learned about Destructuring and Spread Operators those are good handy features as developers mostly work with arrays and objects.

You can see my silly experiments here Repl