8 Simple Ways To Become Better at JavaScript!
Tags: javascript, webdev, frontend, coding
Published: 2024-03-05 03:00:00

_Disclaimer: The following content includes affiliate links. If you buy something through these links, we'll earn a commission without any extra cost to you. Your support is appreciated!_

## Table of contents
- [Introduction](#Introduction)
- [Pick a good JavaScript course](#Pick_a_good_JavaScript_course)
- [Start reading books](#Start_reading_books)
- [Get your HTML DOM knowledge right](#Get_your_HTML_DOM_knowledge_right)
- [Get familiar with the design of JavaScript](#Get_familiar_with_the_design_of_JavaScript)
- [Listen to interviews and conferences](#Listen_to_interviews_and_conferences)
- [Continuously perform simple exercises](#Continuously_perform_simple_exercises)
- [Develop an analytical eye](#Develop_an_analytical_eye)
- [Ask questions when you get stuck](#Ask_questions_when_you_get_stuck)
- [Wrapping up](#Wrapping_up)

## Introduction<a name="Introduction"></a><a name="Introduction"></a>

Without a doubt, [JavaScript](https://www.codeguage.com/courses/js/) is one of the most popular programming languages of all time, by virtue of its core usage on the client side — it's the only scripting language that browsers understand — and also on the server side since the inception of Node.js.

Learning JavaScript is an extremely lucrative thing to get into as it allows us to explore many different arenas in computer science, the likes of web development, app development, game development, data science, and so on.

While it's surely a great language to pick for getting into programming, JavaScript isn't a minimal language comprised of just a few interfaces to explore. Not at all! It is one beast of a language. The bits and pieces of the interfaces are simple to understand but overall the language is flooding with shiny bells and whistles.

It's not that challenging to become fluent in JavaScript, but equally it isn't that easy either.

However, in this article, we cover 8 ways for you to get better, better, and better than ever in JavaScript. Ways to become confident with your knowledge of JavaScript. Ways for you to be able to develop complex applications with ease. Ways for you to teach JavaScript's complex parts to your friends. Ways to excel as a JavaScript dev.

_So shall we get into them?_

-----

## Pick a good JavaScript course<a name="Pick_a_good_JavaScript_course"></a><a name="Pick_a_good_JavaScript_course"></a>

Needless to say, if you opt for a resource that's crafted poorly with a vague structure, pitching in ad-hoc ideas for you to learn, you'll never ever build that confidence to code in JavaScript. You'll always find yourself stuck in what's commonly referred to as a _'tutorial hell'_.

You'll be consuming tutorial after tutorial, resource after resource, but still not able to solve very basic exercises when the time comes to finally execute the learned concepts.

The last thing you want in a course, teaching something as large and complex as JavaScript, is a quick skim-through collection of already-cooked recipes to build feature A or B. _That's just not going to work! Ever!_

Ideally, you want a course that doesn't just contain precooked recipes but instead also contains all the necessary learning materials for you to build your foundation and be able to cook anything yourself, whichever way you like. Even if there are precooked recipes, the intuition behind them must be made clear.

Now while finding a good learning resource for JavaScript is easy, **finding a bad one is easier**. There are tons and tons of bad resources out there. (We're sure you know of them!) A beginner might fall for the extensive lengths of content covered on website A or B without being able to judge that all that content is merely an extension of one single topic.

_So how do you find a good resource for learning JavaScript?_

Well, at least for JavaScript you don't need to worry that much, for we've got you covered.

At Codeguage, we've compiled [one of the most comprehensive JavaScript courses](https://www.codeguage.com/courses/js/) out there, iterating on the course structure numerous times to make sure that it is easy to follow through and valuable for beginners as well as expert developers.

There are superbly comprehensive chapters covering all kinds of different aspects of the language, numerous exercises for you to practice the concepts that you learn, and a bunch of quizzes to test your knowledge in a quantitative way.

And if that's not enough, we're even working on building [one of the largest practice question collections of JavaScript online](https://www.codeguage.com/questions/js/), currently standing at a tally of 309 questions and covering JavaScript's foundation, numbers, and strings. (More questions will follow up in the coming days.)

-----

## Start reading books<a name="Start_reading_books"></a><a name="Start_reading_books"></a>

Besides learning via online courses, we can't emphasize any more on the sheer importance of learning via books. _Yes, books!_

_Do you love reading books in general?_ _No?_ Well, at the very least, you should start to love reading books on JavaScript.

It won't be wrong to assume that well over a thousand books have been published on JavaScript since the day of its inception. JavaScript is everywhere, so how can that ever be true without it being in one of the most supreme resources of all times — books.

Books carry immense value, and are typically written by experts in their fields, with rigorous editorial checks applied, again by industry experts, to make sure that the content covered is of exceptional quality.

So if you aspire to become a proficient JavaScript developer, start reading books starting from today!

Now you might go on and say _"Well, you know what, books are somewhat expensive and add to my minimal desk setup. So maybe I am better off without them when learning JavaScript."_

Now while you're not wrong in your first proposition, you are definitely wrong in your second one.

_We beg to argue on the fact that how can anyone be better off without reading books?_

Believe it or not, even reading one (good) book on JavaScript can bring about a great change in your development skills, especially if that book is based on building a project or multiple projects rather than explaining syntax and language theory using ad-hoc examples. The latter kind is also really helpful, most importantly as a source of quick reference, but in the longer run, you'll value books where authors build an app and along with that explain different concepts.

Anyways, coming back to your statement, yes **books are expensive** and **add to one's physical space** but there are great solutions to these problems in today's digital era.

One of our favorites is **[Perlego](https://perlego.pxf.io/rQxnOv)**. For just **$8/month**, you get to browse from a humongous directory of books, from notable publishers such as Packt, Manning, and Apress, in addition to many many others.

Here are three amazing books that we recommend everyone to read for improving their JavaScript skills:

- [Professional JavaScript for Web Developers, Matt Frisbie](https://perlego.pxf.io/Y9PqZe)
- [Testing JavaScript Applications, Lucas Fernandes da Costa](https://perlego.pxf.io/DKGb45)
- [JavaScript All-in-One For Dummies, Chris Minnick](https://perlego.pxf.io/PyErPj)


If you can go a bit higher than $8, then we'd recommend you to definitely also try out subscribing to **[O'Reilly](https://oreillymedia.pxf.io/k0Eam0)**.

You might've heard of O'Reilly before, but even if you haven't, no problem. Now is the high time to know about it.

O'Reilly is a book publisher, producing an elite collection of books on computers and technology. Seriously, a book from O'Reilly is one big testimonial that it's not just good, but filled with value dripping in every single sentence.

For just **$49/month**, you get to browse from a jaw-dropping inventory of exceptional-quality books, covering different aspects of learning JavaScript.

Some great books worth learning from O'Reilly on JavaScript include:

- [JavaScript: The Definitive Guide, 7th Edition, David Flanagan](https://oreillymedia.pxf.io/nLxRGM)
- [Learning JavaScript Design Patterns, 2nd Edition, Addy Osmani](https://oreillymedia.pxf.io/6eLPOm)


The biggest benefit of purchasing the subscription of O'Reilly is that in addition to books from O'Reilly, you get access to books from other notable publishers as well, including Packt, No Starch Press, Manning, Wiley, Addison-Wesley Professional etc.

-----

## Get your HTML DOM knowledge right<a name="Get_your_HTML_DOM_knowledge_right"></a><a name="Get_your_HTML_DOM_knowledge_right"></a>

For frontend developers, [DOM mutations](https://www.codeguage.com/courses/js/html-dom-introduction) are something they do day in, day out. _Nothing denying that, right?_

Every JavaScript app development framework/library, including the well-known React, Vue and Angular, abstracts away the tediousness of working with the DOM in one way or the other.

The DOM interface is _superbly huge_.

Well that got lost. Let's restate it. The DOM interface is _superbly huge_. Lost again, maybe. Let's do it once more. The DOM interface in JavaScript is _superbly huge_. There is honestly a heck lot of stuff to cover in it.

**💡 Notice**: We're considering both the [CSSOM](https://www.codeguage.com/courses/js/cssom-introduction) and the [Events](https://www.codeguage.com/courses/js/events-introduction) API in the DOM here, even though precisely speaking, they are different ideas.

Knowledge of the DOM is superbly important for every JavaScript developer. Almost every interaction conducted by the user in the browser on any website ends up utilizing some kind of a feature from the DOM.

Therefore, you must make sure to solidify your comprehension of the DOM APIs, and be able to answer such questions as:

- _[What is the `Node` interface?](https://www.codeguage.com/courses/js/html-dom-nodes)_
- _[What is the `Element` interface?](https://www.codeguage.com/courses/js/html-dom-dom-elements)_
- _How to add a new element before a given element?_
- _How to add a new element after a given element?_
- _[What are document fragments and when might we need them?](https://www.codeguage.com/courses/js/html-dom-document-fragments)_


...and so on and so forth.

In our JavaScript course, we have whole units dedicated to exploring the [HTML DOM](https://www.codeguage.com/courses/js/html-dom-introduction), the [CSSOM](https://www.codeguage.com/courses/js/cssom-introduction) and then the [Events](https://www.codeguage.com/courses/js/events-introduction) API in the language. There are numerous exercises for you to tackle to build the necessary fluency of working with the DOM.


> #### A quick exercise for you<a name=""></a>
> 
> As one teaser of an exercise from the course, try creating a `getInnerHTML()` function that replicates the behavior of `innerHTML` when we get it.
> 
> That is, given a `Node` instance `node`, `getInnerHTML(node)` should return the same thing as `node.innerHTML`. The main point of the exercise is to NOT use `innerHTML`, otherwise there's clearly no point of the exercise!
> 
> The full exercise can be read at [Exercise: JavaScript HTML DOM — HTML Serialization](https://www.codeguage.com/courses/js/html-dom-html-serialization-exercise).

-----

## Get familiar with the design of JavaScript<a name="Get_familiar_with_the_design_of_JavaScript"></a><a name="Get_familiar_with_the_design_of_JavaScript"></a>

At some point in time, becoming better at any given programming language comes down to digging into its internals and trying to make some sense from them on how the language works.

For JavaScript, to name a few, you should know about its asynchronous, event-driven execution model; about its prototypal object-oriented nature; and about its strange typing quirks.

Going a bit more specific, you should know such things as:

- [_What is the event loop and how it works?_](https://www.codeguage.com/courses/advanced-js/event-loop)
- [_What are microtasks?_](https://www.codeguage.com/courses/advanced-js/microtasks)
- _Why does the second argument to `setTimeout()` specify the minimum time span after which the given callback fires and not the exact time span?_
- _Why are classes in JavaScript not the same as classes from classic OOP languages, such as Java?_


…and so on and so forth.

But these are questions that don't necessarily require one to dig into the very internals of any implementation of JavaScript; they can, more or less, be answered by theoretical discussions, keeping concrete engine details away.

However, there are certain questions that can only be answered by considering some insights into engine constructions.

These include:

- _How to create objects with the same 'shape' for the sake of better performance?_
- _How to make sure garbage collection doesn't happen often (which can otherwise lead to subpar performance)?_
- _Why keep from assigning arbitrary indexes to arrays in JavaScript in order to prevent them from becoming [sparse arrays](https://www.codeguage.com/courses/js/arrays-basics#Sparse_arrays)?_


Perhaps the best resource to learn about these internals is from the same team behind the best tool that implements them, **V8**. V8 is Google's open-source JavaScript engine, using a JIT-compiling mechanism to execute a JavaScript program.

The [blog of V8](https://v8.dev/blog) has some amazing resources worth reading to get some invaluable insights into JavaScript.

Besides learning from V8's blog, two other blogs worth considering are as follows:

- [Mathias Bynens](https://mathiasbynens.be/)
- [Benedikt Meurer](https://benediktmeurer.de) (Here, search for the _'javascript'_ tag from the side menu and skim through the collection of posts.)


Clearly, learning this deeper knowledge first requires you to be comfortable with the fundamentals of JavaScript. And that comes with a good resource, some solid amount of time, and some great amount of practice.

-----

## Listen to interviews and conferences<a name="Listen_to_interviews_and_conferences"></a><a name="Listen_to_interviews_and_conferences"></a>

_"Interviews? Conferences? How could they possibly help me learn JavaScript?"_, you ask. Well, in _every_ way!

An interview — such as the one between [Lex Fridman and the creator of JavaScript, Brendan Eich](https://www.youtube.com/watch?v=krB0enBeSiE) — and a conference talk — such as the [one that Ryan Dahl gave on the birth of Node.js](https://www.youtube.com/watch?v=EeYvFl7li9E) — are active mediums of learning in contrast to static, passive documents teaching us given concepts via text.

In interviews and conferences, you get to see different tangents of people on different ideas, with the presenters usually talking about numerous side things besides what they are actually presenting.

When you listen to talks revolving around JavaScript, you get to harness a great deal of knowledge from these active conversations and know about various aspects of the language.

_So where do you get started? Where to begin watching these talks, interviews, and conferences?_

Well, it's not really difficult. Head over to YouTube (or even Google, but that won't produce very good results in this case) and search for _'JavaScript conferences'_. Skim through the videos that appear and shortlist the ones whose topics align with your current interests.

And pretty soon, you'll get similar suggestions in your YouTube feed once you watch either of these videos, giving you a steady stream of talks to listen to.

Obviously, this is going to take some effort on your end to find a talk/conference/interview whose topic is watch-worthy, but believe it, the result is worth it all.

-----

## Continuously perform simple exercises<a name="Continuously_perform_simple_exercises"></a><a name="Continuously_perform_simple_exercises"></a>

Regularly solving simple JavaScript exercises is just like going to the gym daily and lifting small weights — it keeps you in shape.

And if you tackle a bit harder ones, similar to lifting slightly heavier weights which ultimately end up with you having bigger and stronger muscles, you get to build some exceptional programming and problem-solving skills.

_Easy formula, isn't it?_

So if you aspire to become a pro JavaScript developer, it's impossible to do so without regularly solving basic, simple computational problems using it.

_So does this mean I should implement a basic prompt-input-based calculator in JavaScript?_ Yes.

_Does this mean I should implement a basic integer check in JavaScript?_ Absolutely yes.

_Does this mean I should write a function to find the maximum number in a given array of numbers?_ Indeed, yes.

The thing is that even though some exercises might seem so elementary to solve that we'd feel tempted to skip them, it's these elementary exercises that help us build muscle memory for typing given syntactic elements of a language (symbols, keywords, indentations) quickly and also keep our problem-solving hygience checked.

These simple exercises help us get a quick warm-up before approaching to solve more difficult programming problems in the near future.

They also get us to start building and following kind-of our own system of coding conventions, for e.g. possibly using the [Allman style](https://en.wikipedia.org/wiki/Indentation_style#Allman_style) or maybe the [K&R style](https://en.wikipedia.org/wiki/Indentation_style#K&R_style) for denoting curly braces in code; having `else` on the same line as the ending `}` of the previous `if`; and so on.

These exercises help us remember the utility of different language features of JavaScript, which in turn pays us off when we go on to build something really complicated.

Surely, the last thing you want while coding an application in JavaScript is not knowing [how to determine if an arbitrary value is an integer or not](https://www.codeguage.com/courses/js/numbers-integers-only-exercise).

-----

## Develop an analytical eye<a name="Develop_an_analytical_eye"></a><a name="Develop_an_analytical_eye"></a>

The next time you visit a website, don't just skim through it and then exit it. No. Try to see the website from an analytical eye, judging different functionalities on the website and trying to reverse engineer them.

For instance, let's say you go to a website to read a blog post. Now, by virtue of your analytical eye, you notice a search bar at the top reading something along the lines _"Press '/' to start searching."_

Immediately this piques your curiosity and leaves you wondering about how this functionality might have been implemented.

_But you're not there to just wonder, are you?_

You go on, spin up a dummy webpage, dump in an `<input>` element in it, and then try cracking setting up a similar functionality in this webpage.

You think about the event required to tap into listening to keyboard events throughout the entire document. Right away, the [`keydown` event](https://www.codeguage.com/courses/js/events-keyboard-events) rings bell. _`keydown` on what?_ `window`, definitely.

_But how to check for the / key?_ Using the `keyCode` property, or even the more modern `key` property, on the given `KeyboardEvent` object provided to the `keydown` handler.

_You get it, right?_

Do give a try to processing websites in this way the next time you see them, thinking at the back of your mind how different functionalities might have been implemented.

Sometimes, such treks can lead you long into territory that you haven't ever explored before. Who knows, maybe such a trek gets you to ultimately learn about the Selection API, or the Clipboard API, or maybe the [Drag and Drop API](https://www.codeguage.com/courses/js/drag-and-drop-basics), and so on.

-----

## Ask questions when you get stuck<a name="Ask_questions_when_you_get_stuck"></a><a name="Ask_questions_when_you_get_stuck"></a>

Reading the heading here, before you go on and ask literally every single question that pops in your mind on StackOverflow or other questionnaire websites, hear this out:

Keep yourself from asking superbly fundamental questions that you should be knowing from whatever resource you're learning JavaScript in the first place. If you don't know answers to fundamental questions, try another resource for learning JavaScript.

Try NOT to ask questions like:

- _[How to check whether an arbitrary value is an integer?](https://www.codeguage.com/courses/js/numbers-integers-only-exercise)_
- _[How to find a given element's index in an array?](https://www.codeguage.com/courses/js/arrays-array-methods)_
- _[Why does `'🙂'.length` return `2` instead of `1`?](https://www.codeguage.com/courses/js/strings-unicode)_
- _[How to check for a `NaN` value in JavaScript?](https://www.codeguage.com/courses/js/numbers-basics#isNaN)_


These questions aren't really subjective — they are purely based on the design and nature of JavaScript, and henceforth, shouldn't end up as new questions of the future. Plus, they've already been answered so there's even less point in asking them once again.

Ask deeper questions or questions that are, more or less, subjective.

For instance, one possible question (although we aren't really setting up a benchmark here, nor stating that such a question hasn't already been answered) might be _"What's the point of the [`Math.imul()`](https://www.codeguage.com/blog/javascript-math-fround-and-imul) method in JavaScript?"_

Keep in mind that we aren't strictly warning you against asking questions that are close to fundamental; we're just trying to say that you should keep yourself from initiating such questions as much as you can, for their answers are usually objective, not subjective, only requiring you to put in some effort and get your fundamentals intact.

Subjective questions usually get one to learn a lot.

Here's one possible scenario where asking a question might help.

_Creating an application and have two different approaches to take to implement a feature A?_ _Can't decide which approach to take probably because you're not that experienced in building such a feature?_ Well, this is the perfect point to ask for help from an expert.

Questionnaire sites such as [Reddit](https://www.reddit.com/) and [StackOverflow](https://stackoverflow.com/) host a great number of experts who can help you out with your problem, and in that way, help you gain a considerable amount of knowledge regarding JavaScript.

-----

## Wrapping up<a name="Wrapping_up"></a><a name="Wrapping_up"></a>

And that's it guys for our 8 simple ways to become better at JavaScript.

Honestly speaking, mastering JavaScript isn't _as hard_ as people out there tend to portray it. After all, teams are developing such complex applications as [Figma](https://www.figma.com/), using extremely low-level JavaScript interfaces, including those allowing us to work with memory buffers, OpenGL, audio, and much more.

The complexity of JavaScript apps is on the rise and with Node.js, enabling us to hop on to exploring the server end as well, it's only going to become even more prevalent in the near future.

So without wasting any more of your time, put these 8 ways into action starting from now! Or if you've already gone through either one of them already before, let us know in the comments below about the effect it had on your expertise of JavaScript.

Keep learning and keep growing! And please take a small break from your screen, for this article was quite a long one. 🙂

-----