7 Mistakes That Keep You Behind
Tags: javascript, webdev, react
Published: 2019-06-28 02:42:30

Find me on [Medium](https://medium.com/@jsmanifest)

Learning JavaScript isn't fun for everybody, especially for people who are impatient. Sometimes there comes a point where people start to question if this is even the right career path for them.

But JavaScript was never meant to be a walk in the park.

The _good news_ is that your learning process can be improved by making better decisions and approaches to learning. The _bad_ news? Well, it won't happen on its own. The only person who can change all this is _you_.

This article will go over 7 mistakes developers tend to make that are keeping them behind while learning to become better in JavaScript.

## 1. Rushing Through Concepts

![rushing through concepts](https://jsmanifest.s3-us-west-1.amazonaws.com/posts/7-mistakes-that-are-keeping-you-behind/rushing-through-concepts.jpg)

Once you begin to understand concepts like [closures](http://javascriptissexy.com/understand-javascript-closures-with-ease/) or [higher order functions](https://codeburst.io/here-are-7-ways-higher-order-functions-can-improve-your-life-a392aa6b29d2), it's _almost never_ a good idea to skip to the next lesson without some hands-on experience first.

But it may be super tempting to move on to the next subject, I know. It happens to everyone. But believe me, if you spend some time hands-on coding in between, even for just five minutes, it will help you to have an easier time building projects in the future. Often the _feel_ of coding a concept is what will stick to your mind and help you to remember things in the long run.

If you do end up rushing through concepts you'll end up forgetting and searching through old materials in attempts to refresh your memory. When this happens, it can be awfully discouraging as you're losing valuable time when you already "learned" this before. _Then_ those negative thoughts start to pile up in your head.

And that's important, because people often say they [quit their programming career](https://javascriptissexy.com/a-significant-number-of-students-quit-their-programming-education-find-out-why-before-you-sign-up-for-a-program-and-suffer-the-same-fate/) due to _insufficient time_.

When you feel like a concept is a piece of cake to you, you should be ready to move further!

## 2. Not Owning Your Code

![not owning your code](https://jsmanifest.s3-us-west-1.amazonaws.com/posts/7-mistakes-that-are-keeping-you-behind/not+owning+your+code.jpg)

A common thing I still see today are people becoming too dependent on other people's work--whether this is copying another person's file from a tutorial or using the lodash library to do everything. While there's _nothing wrong_ with using lodash for a lot of your tasks, you can also be setting yourself back in the long run if you haven't applied many of those concepts yourselves yet. The concepts is what will _stick to other tools/frameworks/languages_ because they're _ways to think in programming_.

This is the reason why a lot of interviews still give coding challenges. They want to see how you think or how you apply concepts to common problems in development. You can be using component libraries alone to make the best looking user interface while making lodash handle applying the algorithms for you, but when problems arise they need you to be ready to apply concepts and solve them. They don't look forward to *npm install*ing another library to solve their problems. They need _you_.

You don't want to end up in situations where you're having hard times applying concepts you've already learned. So it's a generally a good idea to take a bit of your time to practice them on your own. _Own your code_!

## 3. Overthinking Everything

![Overthinking everything when learning javascript](https://jsmanifest.s3-us-west-1.amazonaws.com/posts/7-mistakes-that-are-keeping-you-behind/overthinking+everything+when+learning+javascript.jpg)

With all of information you can find online, it can be _very_ tempting to sit down and gather all of the resources you need before learning the next topic in JavaScript.

But I don't think I've seen anyone say that it was the way to learn and become better. Yet we seem to have the urge doing that because we desire having all the information in front of us so we feel set for the rest of the year.

_It's all in your head_.

Don't get too caught up in the act of gathering 80 tutorials, 6 ebooks, a collection of over 50 bookmarks of resources, and attempting to start tackling them down together for as long as you feel like the king of web development.

If you're learning JavaScript, get your hands dirty with hands-on learning. Just starting writing things. Use whatever you learned the past hour and put together a small example for yourself. These activities are what will end up sticking to your head longer instead of having to read through a marathon of all this learning material you gathered.

## 4. Overwhelming Yourself With Too Much Information

![overwhelming yourself with too much information in javascript](https://jsmanifest.s3-us-west-1.amazonaws.com/posts/7-mistakes-that-are-keeping-you-behind/overwhelming+yourself+with+too+much+information+in+javascript.jpg)

When you're spending lots of your time taking in information instead of coding in between, you're actually setting yourself up to forget and come back to the material later.

A scary place to set yourself in is spending all this time learning because you _feel like_ your learning. But what happens a couple of months later when you end up forgetting? You'll find that for some reason you're unable to apply the concepts and material you've learned months ago.

If you need advice, spend at least fifteen minutes coding for every one hour of consuming information.

## 5. Comparing Yourself To More Advanced Developers

![comparing yourself to more advanced developers](https://jsmanifest.s3-us-west-1.amazonaws.com/posts/7-mistakes-that-are-keeping-you-behind/comparing+yourself+to+more+advanced+developers.jpg)

When you compare yourself to others you're actually not thinking about _how_ they got there--instead of you're just thinking about where they're at _now_.

When people look at successful programmers like [Dan Abramov](https://twitter.com/dan_abramov) they would automatically assume their learning process began with writing clean code from the start.

Just keep focusing on what you're learning in the present and you'll continue to get better as you go. Soon you'll end up being in a position where people start wondering about how _you_ got there.

## 6. Learning The Tools and Frameworks Built On Top of JavaScript

![learning the tools and frameworks built on top of javascript](https://jsmanifest.s3-us-west-1.amazonaws.com/posts/7-mistakes-that-are-keeping-you-behind/learning+the+tools+and+frameworks+in+javascript.jpg)

So you're supposed to be learning JavaScript but you're learning React/jQuery/Angular/Vue right away instead. What happens when a new revolutionary tool comes out and you make the switch? You're going to end up relying on someone else to figure out the neat tricks and hope someone shares them because they learned JavaScript and you didn't!

If you haven't sacrificed a good amount of your energy into learning vanilla JavaScript, I highly recommend to _really_ learn the language--because if you learn the language, then you should understand the tools that were built on top of it, _why_ they were being built and _what_ problems they solve. By learning the _why_ in JavaScript it will help you avoid making bad code design decisions as well.

One of the most regretful mistakes I made in all of the history in my career is learning jQuery before I started learning JavaScript at the time. When React came along, I _hopped on the bandwagon_ and began learning React. However, this became a _very awkward_ learning process after I realized I didn't _know why I had to use react or why people needed it_. It suddenly just became a game of memorizing react code just to get by. In JavaScript tools or frameworks, a lot of the important bits are hidden away that _you need to see_ but aren't.

## 7. Not Splitting Concepts To Smaller Pieces

![not splitting concepts to smaller pieces in javascript](https://jsmanifest.s3-us-west-1.amazonaws.com/posts/7-mistakes-that-are-keeping-you-behind/not+splitting+concepts+into+smaller+pieces+when+learning+javascript.jpg)

Learning JavaScript is like learning math while growing up. Once you learned the basics of addition, multiplication, division, substraction, [you can move on](https://www.understood.org/en/learning-attention-issues/signs-symptoms/age-by-age-learning-skills/math-skills-what-to-expect-at-different-ages) to comparing numbers using _> (greater than)_ and _< (less than)_, long division, basic algebra, etc. When you find yourself having difficulty trying to understand something, it's often because you jumped far ahead instead of taking small steps. Of course going straight to algebra will feel impossible without going through the basics first :)

By taking small steps and encountering a concept that isn't making sense to you, it _will_ be a lot easier for you to get assistance because you'll already have the topic narrowed down.

Follow me on [Medium](https://medium.com/@jsmanifest) if you have one!