Never. Ever. Jump. To. Libraries.

Here's the deal: You go, learn a few basics in JS and then start with React. You like it and it is simple, but some stuff is missing. So you go and add jQuery to the site. Nice and easy, nothing complex. Oh, but then again, you miss some functionality. So you add d3.js.

During development, you find out that there is a bug in one of the libraries you use. You do a quick google search and find out that the bug has been issued in the bugtracker three years ago, but no one cares to fix it. So you take a look at the source, but it looks like very advanced and complicated VanillaJS, so you decide to use yet another library as a workaround.

Finally, you built a nice site and you kinda know how to work with the frameworks and libraries you learned. Nice, Feelin' pro, yet?

There is a little problem, however: Your site loads very very slowly. So you profile the app and find out that downloading a few megabytes of libraries takes up all the time. Even worse: Mobile users start complaining that the site does not load at all and that you take up all of their data volume. That's when you start with more code which does caching and displays funny loading animations etc. Fewer users complain, so everything seems OK.

Well, bad luck, because Facebook announces that they abandon React in favor of their next big thing ("Hack: Move fast and break things"). The jQuery guys come to the conclusion that they need to rethink their strategy, for whatever reason you used jQuery, you will need another library instead if you want bugfixes. Oh, and d3.js adds new syntax. Holy cow! Now you have to re-learn everything and search for new solutions, which you have to learn in addition.

See how you constantly have to learn basic stuff in order to continue coding with latest tech? Let's take a look at the Vanilla way.

• There were a few iterations of JS/ES, but all in all not many new features each time.
• JS is forward/backward compatible, so you can gradually start using new things, and your old code will always work.
• It's very predictable what will happen when, because JS is standardized, so there has to be a public draft first and you know what will happen way before it happens.
• JS will be there for a very long time, because a lot of browsers use it and completely changing what drives the web will take decades.
• VanillaJS is only the logic you ship, so no dead code or complex build environments and tons of data you have to transfer.
• VanillaJS is fast! Because the JS VM only has to interpret a little bit and then do the heavy lifting in efficient machine-code (your libraries will essentially do the same, but with an overhead)
• Everything is written in VanillaJS at some point, so learning new stuff based on VanillaJS and fixing bugs in VanillaJS is really easy!

You see, jumping to libraries might look promising in the short-run, but you will benefit a lot more from learning the real deal :)

If you need more arguments, please search Hashnode a bit, we have a ton of posts with arguments for and against VanillaJS, for example:

• How far can you go with Vanilla JS?
• Modern JavaScript development workflow is screwed up. What can we do to make this right?
• Vanilla JavaScript vs. Frameworks & Libraries — Finding a good balance

The most important library / framework you should learn:

Vanilla-JS

Vanilla JS is leaps and bounds better than any library out there right now. I'm going to predict that it's the next hot thing that all employers will be hiring web developers for.

At least learning a lot of the gotchas such as this in Javascript (see here) can help you sometimes avoid headaches when trying to debug code. But learning the basics and jumping to frameworks is probably fine.

Check out: medium.com/re-dom/master-the-dom-bc1a2a06089b

😉

Good to know, but you can jump into learning libraries

It's always good to understand what happens behind the hood. If you don't have any particular deadlines, I recommend you to spend more time on learning pure JS/ES6.