The sad part? There was no need to give up. All that was needed was a different learning approach.
Let’s dive in!
Mistake #1: Overanalyzing Instead of Getting Started
Whether or not these points have validity, nothing is worse than the six months to a year you’ll waste agonizing instead of starting.
Just type one line of code. It doesn’t have to be perfect. It can be terrible. If you get started, you’ve already passed one of the hurdles that stop a lot of people.
However, if you jump straight into a framework, you’ll end up memorizing without understanding. It’s like trying to write sentences without knowing what words mean. You’ll end up memorizing random phrases instead of understanding how words work and how to put them together to make your own sentences.
Mistake #3: Moving to the Next Step Too Soon
One of the most common mistakes is to move on immediately after understanding a concept.
I’ve definitely struggled with this one because it’s tempting to move forwards once you understand something.
What helped was to treat each concept like a new toy; That means taking some time to enjoy what you just learned. Play around, experiment, see if you can do something new with it. You’ll learn a lot that way, and you’ll remember better as well.
Once you feel like you can apply a concept in your sleep, move on. It takes a little bit more time up front, but soon it makes everything go much faster.
Mistake #4: Not Breaking Concepts Into Small Enough Pieces
Learning is like a staircase: If you can take one step, you can keep taking more steps until you reach your goals. When something is tough to understand, it’s often because you’re trying to take a flying leap instead of going one step at a time. Of course, it seems impossible!
In practical terms, I’ve seen situations where people would struggle to understand a piece of code. I would ask them to explain it, and they’d get tripped up trying to explain the entire thing at once. I’d ask them to explain it again, but this time line by line, and that was when it made sense.
If something seems confusing, there’s often a step that’s being skipped, so it helps to focus on smaller and smaller pieces until you find the sticking point. If a concept still doesn’t make sense after breaking it down, you’ll have an easier time searching for help because it’s easier to look up specific topics than vague ones.
Mistake #5: Attempting a Complex Project Too Early
I’ve written about projects in more detail, but the gist is that it’s often easier to start with some fundamental concepts first. That way you have some building blocks in your toolkit for when you start doing projects.
To be clear, I’m not saying to go overboard and avoid projects for a long time. I’ve just found it easier to start projects if I’ve done some fundamental things first, like showing some text in the browser or responding to a button click.
Mistake #6: Not Practicing Under Real-Life Conditions
These approaches can be great for learning, but it’s also important to try the material on your own. That would mean using your own text editor and coding a concept from scratch.
If you don’t take a bit of time to practice each concept on your own, you’ll come to depend on the training wheels. Then you end up in a situation where you’ve spent all this time learning, but you can’t seem to apply any of it on your own.
Mistake #7: Comparing Yourself to More Advanced Developers
One of the easiest ways to get discouraged is to compare yourself to more advanced people. That’s because you’re looking at where they are instead of how they got there.
The truth is that my process was a mess. I experimented, made mistakes, looked things up, wrote ugly code, and finally refined everything into a presentable tutorial. People saw the polished version, and assumed the whole process was like that. I also made these assumptions about tutorial authors until I started writing my own.
The point is, just focus on what you’re learning right now and you’ll get better at that. Keep repeating this process, and soon you’ll be at a point where other people wonder how you got there.
Mistake #8: Consuming Information and Not Actually Coding
It’s easy to spend a lot of time watching videos and reading tutorials, but you won’t really learn unless you actually write code.
The dangerous part about consuming information without acting on it is that you’ll feel like you’re learning. Then six months later, you’ll find yourself unable to apply any of what you’ve learned.
Fifteen minutes of actually coding can often teach you more than an hour of consuming information.
Mistake #9: Following Tutorials Without Understanding or Experimenting
When reading tutorials, it’s tempting to just copy the steps in a linear way. This approach doesn’t teach the process of solving a problem, which typically involves experimenting and taking small steps in various directions. As a result, someone who follows tutorials in a linear way will often be unable to apply the knowledge afterwards.
So what’s the solution?
Instead of copying each step, take time to experiment. For example, if you’re doing a slideshow tutorial, experiment with showing and hiding divs, then experiment with timing, and then try another small piece. You’ll learn much more through experiments than through the linear approach, and you’ll be able to apply it better too.
If there’s one thing I want you to remember from this article, it’s that you’ll make the biggest progress by taking the smallest steps.
Whatever it is you’re learning, get comfortable with the fundamentals. Experiment with what you’ve learned, and have fun.
It might be difficult sometimes, but that’s good. The challenge means you’re stretching your abilities, and that’s what will make you improve. If everything is always too easy, that might mean something needs to change.
Your First Year in Code
Visual Studio Code: End-to-End Editing and Debugging Tools for Web Developers