How To Actually Learn Using Coding Tutorials?

A call to utilize a time-tested technique

Photo by Markus Winkler on Unsplash

Coding skills open us up to a myriad of possibilities to interact with the world in innovative and creative ways. How desirable this may be, it is not so easily achievable due to the complexity involved.

Solving programming problems, building projects and playing coding games are all marvelous and popular ways (given the right context) to become a better coder. What all of these ways share is that they all encourage us to create some thing, or in programmers terms, to output information.

The type of learning that motivates us to actually make something happen (output) is called active learning. This we can contrast with passive learning (input), another dimension of learning that includes, you quest it, watching coding tutorials.

Even though proponents of active learning style have strong arguments for the value of this method. We wouldn’t be right to undermine the value of passive learning. It really shouldn’t come as a surprise to anyone that the quality of work we do does depend on the information we gather or have gathered. Just like the quality of output depends on the quality of input.

Now, how to maximize what we retain after watching coding tutorials?

The trick here is quite simple. What we should aim for is a sort of synchronization of the two mentioned learning methods in order to actually understand the coding material. Which in turn can be done with a time-tested active learning technique.

The infamous learning Technique of Richard Feynman that is. A technique used for many purposes by millions of people worldwide that brilliantly encourages us to teach in order to learn or to explain in order to understand. Applying this can successfully serve a complementary role in truly understanding thy code. As your attention will inevitably be drawn to the aspects of coding that are yet to be better grasped.

This way of learning can be employed in combination with coding tutorials in the following three phases.

1. The phase of explanation. At this point you should attempt to produce a very clear explanation of the material that was presented in a given tutorial. So clear in fact that even a six year old should be able to follow your thought process or, simply put, understand your output. This is a very powerful part of this technique because it will help you to encounter those aspects of coding you do not yet comprehend completely. When you reach this point of knowing what you do not know you can start the second phase.
2. Revisit of the coding material you were trying to explain in the first place, that is. Which likely doesn’t sound especially exciting yet is of great usefulness. Since here you get a chance to fill those gaps in knowledge you learned about in the previous stage. This time around you can be more selective and focused on those bits of information that are evidently the most relevant in your particular situation for you to gather or input.
3. Lastly, switch back to active style of learning. In this final phase you should refine your initial attempts of explanation to produce an even simpler output. Here you should aim to make use of those bits of information you gathered in the second phase to be able to communicate the chosen coding material coherently.

The last two phases can at times be seen as a sort of loop. While the condition that ends it is a crystal clear comprehension of the programming material in the tutorial. Thus if you feel that your explanation of the coding aspects from a given video is still a bit fuzzy, revisit programming material and try to produce an explanation that is even more explicit.

In which ever form you decide to output information is really secondary when it comes down to really understanding the material well. And the forms are many. You could make a tutorial of your own for instance, write a blog post or start an educational conversation. It is really up to your personal preferences.

In essence, this technique encourages a kind of back and forth between going from a source material to actively processing it till the point of satisfactory comprehension. Hence the potential of it to help you to go from passively consuming coding tutorials to actually learning what they have to teach.