To Learn Programming, Be a Wordsmith Not a Programmer
As students of programming we aspire to the higher level of mastery by churning out thousands of lines of code or actively seeking out new paradigms. While immersing ourselves into the sea of knowledge can certainly help us learn programming, in our monomaniacal pursuit for growth we are missing one crucial part that is integral to our growth as programmers. We need to start giving clear forms to new ideas by writing them down in clear words of our own.
Programming concepts are naturally abstract and tend to elude our understanding. And unless we can reproduce them on a paper in clear writing, we might as well have not successfully grokked them. Such elusive nature of knowledge is the reason that learning is hard in general, especially learning programming.
At times of searching for solutions, you might be stuck because you do not even know what to search for. Even when you manage to reach a solution, you might be not completely sure why things work they do. Such situations are only natural; they arise because abstract programming notions escape our attempt to understand them. In platforms such as Codementor or Stack Overflow, we can finally put those ideas into words. It is in such moments that we give a clear 'form' to the ineffable. We learn and grow as programmers.
Yet we must not stop there because our potential is too great and ambition for the mastery so touching. While teaching myself to program, I always wanted to go one step further: to make sense of the abstract notions on my own terms. Therefore I started writing down what I learned every day on my notebook.
Whenever I came across a new concept or a known concept became clearer to me, I stopped what I was doing, opened up my notebook and wrote down the lesson in my own words. After a few months, there were many notes with interesting bits of knowledge. Yet to my dismay they were not super helpful for learning to program after all. The reasons were twofold:
To write a note this way, we have to stop what we are doing and perform many boilerplate actions such as opening up notebook and saving it. By the time we are done, we lose context of what we were originally doing.
We rarely go back to look at our old notes. They just pile up and we end up forget the very things we tried consciously to learn.
As a learner of programming I found these limitations rather disappointing and one night, wrote a 300 line program to simplify the flow and open sourced it under MIT license. It is a command line interface called Dnote. I have been using it for a year, along with many other developers who integrated it into our workflow.
Basically, whenever we learn something new while in a console, we can run
dnote add to quickly write a note. Because many of us use different machine at work and at home, there is
dnote sync command which syncs the local note with the Dnote Cloud with automatic conflict resolution. And since we learn many things while reading Stack Overflow or technical articles, I wrote a Firefox and Chrome extension and open sourced it under MIT license.
There is also a simple script running behind the scene to send email digests every week, detailing things that we have learned in past. This way, we have been able to write down what we learn instantly and forget about it until the computer automatically reminds us.
Through this journey what became clear was that we might be learning programming in a very inefficient way. Trying to rise to the height of engineering knowledge by simply getting our hands dirty will not work because that way, ideas remain foreign to us in their abstract form, and the meager grip we come to have on them will slip away as we naturally forget. In this light, to learn programming we need something more than programming.
Certainly we can read technical articles or seek out mentors to maximize our learning potential; yet above all, we need to be wordsmiths, not a coder. To learn is to give semblance to the abstract notions that intimidate us. I feel that as learners of programming, we are not doing enough to capture that which we learn. In turn, we are reducing ourselves to mere passersby of knowledge when we should be bringing ourselves closer to their essence. We have all the more reasons to do so because only then we will learn to program.