莫听穿林打叶声,何妨吟啸且徐行。竹杖芒鞋轻胜马,谁怕?一蓑烟雨任平生。 料峭春风吹酒醒,微冷,山头斜照却相迎。回首向来萧瑟处,归去。也无风雨也无晴。

What detours may be encountered in the process of learning programming, and what experiences can be referred to?

In the process of learning programming, I have encountered many detours. Some detours are short, like taking a walk, and you can come out immediately, which is a good thing as it increases experience. Some detours are like a series of difficult turns, even experienced programmers can easily crash. But there are also some detours that are even more terrifying. The first half is straight, but the second half suddenly takes a big turn. You may think you are walking on the right path, but in reality, you are going in the opposite direction without realizing it.

One "invisible detour" that I know of is learning programming with a student's mindset.


  1. Taking Notes vs Writing Technical Tutorials
    In our years of studying, the process of acquiring knowledge usually involves the following steps: studying the tutorial examples given in textbooks, practicing the exercises after class, and repeating this process until passing the exams.

Many people with a student mindset tend to apply this learning method to programming: learning basic syntax, practicing a few small tutorial examples, and repeating this process until they think they have learned programming.

In the process of learning programming, the habit of taking notes while reading books has turned into copying code, including variable names, whether to break lines in if statements, and completely copying function names from the book's examples.

It is undeniable that copying code in the early stages is a good way to get started. Successfully running the code each time greatly enhances confidence in learning programming. However, continuously copying code is obviously not a rational behavior and needs to be adjusted to writing technical tutorials.

When you write technical tutorials yourself, you will inevitably review the entire process and even personally perform the operations again. It is easy to discover the omissions in the previous learning process. In order to understand them, you will search for relevant information and supplement your knowledge.

Furthermore, since the technical tutorials you write are published online, in order to make them understandable and recognized by more people, you will definitely try to explain them as clearly as possible. In the process of explaining clearly, you will have a more comprehensive understanding of the knowledge you have learned.

  1. Fear of the Unknown vs Accepting the Unknown
    During our student days, we always thirsted for knowledge and tried our best to understand all the difficult problems. Students are afraid of the unknown, afraid of all uncertain problems. They don't know which scope the problem belongs to, and once they can't find a direction for the problem, they will always fall into a state of anxiety.

Since the scope of the learned content is limited, it is always possible to find clear answers through books, classmates, teachers, and the internet, even if you can't understand it, you know clearly which specific scope the knowledge point belongs to, it's just that you can't solve the problem yourself.

But programming is different. Many programming problems have no solution, and no one knows how to solve them.

In order to learn programming well, we must tolerate a certain level of unknowns.

The unknown will always exist. This is an objective law of reality that cannot be changed by human will. It is futile to struggle against objective reality.

Furthermore, some unknown things are unsolvable. Investing time and energy into unsolvable things is a waste. Some unknown things are due to insufficient knowledge reserves at the moment. You need to endure the current unknowns, grit your teeth, persist in learning the content that comes after, and then you can find the answers.

  1. Following a Set Order vs Constantly Retracing
    The content in textbooks progresses step by step. If you haven't learned the A content before, you won't understand the B content at all.

Due to the existence of unknowns, there are always some problems that will hinder us in the process of learning programming. What we need to do is to first record them, then set them aside, continue moving forward, continue learning new knowledge, practicing new skills, and exploring new fields, constantly accumulating and growing. Occasionally, we can retrace our steps and re-examine those problems. Maybe when we learn a new knowledge point, practice a new skill, or explore a new field, we suddenly have a clear understanding: Oh, so that's how it is.

Ownership of this post data is guaranteed by blockchain and smart contracts to the creator alone.