Writing down my everyday learning is one of the things I would immediately start doing if I was to learn to program all over again. Doing so is a very simple yet powerful strategy to learn and grow more effectively.
Many pundits will tell you that the best way to learn is by “getting your hands dirty.” However, when it comes to programming I find that learning by doing is overrated. Such advice may be relevant to physical activities but not so much to intellectual ones. For instance, professional fighters do an enormous amount of pad work and sparring to train their bodies to slip and weave incoming punches. But as programmers, we can only do so much to imprint on our muscle memory how to build good software.
It is far more important to actually remember the things you learn while programming than to simply churn out lines after lines of code. While writing software, we cannot simply slip a punch, or stuff a takedown based on thousands of times of repetition. Rather we have to understand the inner workings of features, algorithms or data structure relevant to the problem at hand. Simply writing programs over and over does not necessarily give us deep understanding required to build good software.
Consuming tutorials or third party information does not take us very far either. How many “How to Build X” or “Learn X in Y minutes” materials have you consumed, and how much knowledge have you actually retained to this date? Unless we actively try to remember what we learn, instructions are largely wont to be forgotten no matter how eager we are to learn.
Retaining Our Knowledge
The problem with learning by doing or following tutorials is that they ignore the fact that we forget things quickly. Our memory goes away very quickly unless we actively try to retain it. In psychology, this tendency is modelled by the forgetting curve shown below.
As the forgetting curve shows, our memory of new information fades exponentially. The subject of programming is so broad that if we simply keep learning mindlessly, there will be very little repetition necessary to refresh the memory. In other words, without a clear intention of retaining our knowledge, our effort for learning does not amount to much fruition.
During the years of teaching myself to program, I realized that if I wrote down some things, I could remember them better by reading them later. Therefore, three years ago, I started to keep a journal of things I learned while coding for work and leisure. On weekends or downtimes, I would sometimes look at the notes, and every time it amazed me that I actually forgot a lot of what I myself had written down. And each time I read the contents, they became easier to remember in everyday situations. In other words, the spaced repetition made my knowledge more solid.
Moreover, I was able to understand things even more clearly when I wrote them down in my own words. Normally I would have simply read things such as Stack Overflow answers for one-time use, and would have forgotten about them. But now I had to think about the information little more carefully and eliminate all gray areas. Otherwise, I could not succinctly reproduce the knowledge in my own words. It was almost like having a quality assurance for my everyday learning.
Optimizing the Process
By writing down what we learn and revisiting them, we can forget less and remember more. That is, the spaced repetition helps us retain our knowledge. Now our forgetting curve looks more like this:
Yet I found two areas of weakness in my system of keeping programming journals. First, there was too much friction for writing notes because I had to open up a note-taking application, navigate into a particular note before I could write something. When we are deep into a programming task, such context switching can be very counterproductive. Second, I kept on forgetting to revisit the notes I took and went on for months without ever looking at them again because nothing encouraged or reminded me to do so.
Taking the matter into my own hands, I solved these problems last year by making an open source software called Dnote. It is closely integrated into the everyday environment to minimize context switching. That is to say, Dnote can write technical notes from CLI, browser extension, and IDEs. Also, I automated the spaced repetition by running a job to send out an email digest every week. Overall, the system has been helpful not only for myself but also for other developers who have adopted it.
Write Down Your Learning
I believe that writing down learning can benefit all programmers, experienced or novice. Doing so enables us to revisit our learning which is essential given our propensity to forget. Also, writing down a piece of knowledge ensures that we do not feign an understanding. In other words, when we require ourselves to reproduce a knowledge in our own terms, we see clearly which part of a knowledge we do not understand.
While it is important to keep learning in our careers as engineers, it is even more important to learn how to learn, precisely because we have to keep learning. As we begin to write down what we learn, we begin to develop some system in place that helps us grow every day. And with it, we can not only learn more but also learn how to learn more effectively. In the process, you might even find some unique things about how you learn.
Let us grow one piece of knowledge at a time, one repetition at a time. For we do not grow one line of code or one tutorial at a time. As students of engineering, we advance by taking small steps toward the mastery, one foot in front of another. And when we inevitably take two steps back, let us take three steps forward. And when we take one step back, we will take two steps forward. That slow yet steady progress is what learning eventually comes down to.