You're continually asking yourself: are you're doing the right thing? Is there something important you're missing? What are you meant to do next?
Not all learning methods are equal: the time you spend glancing over yet-another explanation of prototypal inheritance (that you still don't understand) isn't as beneficial as when you're 20 chrome tabs into solving an inheritance problem.
If you're looking to make the most of your time, there's a simple cycle that you should be underpinning your learning:
Write, Research, Repeat
The key takeaway here is that your entire learning path should be driven by writing code. It's a skill you have to develop, so there's no substitute for practice. The trick is finding a constant stream of ideas.
The ultimate process is straightforward, however. Write code until you get stuck, and then research your problem until you get unstuck. Over time, you'll need to research less and less.
Of course, if you can't write any code, then this advice isn't useful to you, so I've divided up this strategy into various learning stages to give you a more granular approach.
You have three phases of learning, where the strategy differs slightly:
- Introduction Phase
- Growth Phase
- Honing Phase
No, not at this stage.
The challenge most people have with the introduction phase is that they try to learn far too much before attempting to apply their knowledge. They try to run before they can walk.
Courses will teach you a language, but they won't teach you how to build software – that's something that you can only learn from practising. You want to keep the period where you are only working from a course as short as possible.
This phase is the point where you have enough knowledge to write code, but everything's clunky, and you're still missing significant amounts of knowledge.
Initially, I recommend you completely stop your course for a while, and spend some time creating several practice projects to solidify what you learned during the introduction phase.
When you're more confident in the basics, you should re-incorporate your course back into your learning. Doing a section in between projects is a good approach.
When you've finished your course, it's a good chance to stretch yourself and try new things. Experiment, and work on the areas that interest you: Frameworks, CSS drawings, WebGL, Node. Have fun with it. It's all valuable.
This phase isn't clear-cut like the other two. The honing phase is an extension of the growth phase, but we start working on more ambitious projects. Chances are you are still missing significant amounts of knowledge, but coding is comfortable now.
You're ready to start the honing phase when you aren't lost when working on code. You're able to imagine your own solutions to problems (even if you have to google the specifics). This article might help you.
This is the time to practice softer aspects of programming, like the code quality and structure. Start learning best-practices, like testing, commenting your code, and (if necessary) writing docs.
You can now also assemble and refine your portfolio, and use it to apply for Junior roles. It can take a long time, though, so I wouldn't make it a priority. You can also start on interview prep through sites like HackerRank.
Although it sounds cheesy, the most critical part of this entire process is to make sure you're having fun. Learning to code is a slow process, and it's going to be much easier to keep your motivation if you're enjoying yourself.
I've linked this article multiple times already, but I strongly recommend you check out this guide on choosing ideas for practice projects. Get out there and write. some. damn. code.