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 consuming tutorials. While immersing ourselves into the sea of knowledge can certainly help us learn programming, in our monomaniacal pursuit for growth we are missing an important part of our growth as programmers. We need to start giving clear forms to new ideas by writing them down in clear words of our own.

Like many other ideas, programming concepts are often abstract and tend to elude our understanding. And unless we can reproduce them on a paper in clear writings, we might as well have not learned them. How many technical talks or articles have you watched whose main ideas you can employ at your will to solve your problems at hand? For me, the answer is not many and I suspect the same for others. Those ideas are actually someone else's and not yours, unless you do something to retain them.

Therefore, to firmly grasp abstract programming ideas, we must conceptualize the new notions on our own terms. For instance, when you are stuck while learning to code, you may not even know what to search for. Such situation is only natural; they arise because complex ideas escape our attempt to understand them. When we manage to look up a solution despite all odds, we finally give a clear 'form' to an 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, in my own words.

Whenever I came across a new concept, I stopped what I was doing, opened up my notebook and wrote down the lesson in my own words. After a few months, I was able to accumulate a sizeable number of 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:

1. 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.

2. 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 ended up writing a 300 line program to simplify the flow. It is a command line interface called Dnote, open source under the MIT license. 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 Chrome extension and a Firefox addon which are also open source under the 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 stop worrying 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 forever remain foreign to us in their abstract form. The meager grip we come to have on them will slip away as we naturally forget. In this light, to learn programming we need to do something more than programming.

Simply reading technical articles or consuming tutorials will only take us so far. To absorb the programming ideas to our cores, we need to be wordsmiths, not coders. 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 what we learn. In turn, we are reducing ourselves to mere passersby of knowledge. When an abstract idea is born again in our own words, we become more knowledge and more mature as programmers.