5 obstacles that new programmers must overcome

Many people want to become a programmer or switch to a new career. However, it is not easy to become a qualified programmer. As a novice who wants to get started with programming, there are 5 obstacles that must be overcome. Here I will tell you one by one and explain how to overcome them.

[[142932]]

1. Not sure which language to choose

Many people will ask: "What programming language should I learn first?" The reason you ask this question is naturally because you understand the detailed division of programs, but it also shows that your cognition only stays at this level.

If you already have a goal in mind or a project you want to complete, you can make a choice based on that.

1. If you want to build iOS apps, then you need to learn Objective C or Swift.

2. If you want to build Android apps, then you need to learn Java.

3. If you want to build web apps, then you need to learn JavaScript.

In fact, we can now use JavaScript to create any type of project - from simple web and mobile apps to advanced hardware projects. It can be found in most industries: music, medical, games, fashion, etc.

The probability of this language being eliminated is extremely low, and the market demand is wide. If you are looking for stability, then I suggest you learn this language.

2. Not knowing how to apply what you have learned

After choosing a direction, it is always easy to learn the theory at first, and there are many free and paid online courses on the Internet.

Many people can grasp theoretical knowledge relatively quickly, and can even explain how a piece of code works, but when it comes to actually applying theory to solve problems and write new code, they are overwhelmed.

The reason for this situation is simple: a skills gap.

Take swimming, for example. You can read tons of technical articles and explain them like a pro. But actually applying the theory requires a lot of practice, struggle, and error—and you’ll definitely swallow a lot of water!

So we need to combine theory with a lot of practice. The specific steps are as follows:

1. Choose a complex project. ***This project should be able to arouse your interest.

2. Split this task into small and independent tasks. For example, "Implement the login page" is a big task. But you can break it down into multiple small tasks. And we can break down a small task again: it should not exceed about 20 lines of code. Don't use too many theoretical concepts at a time. Focus on one task at a time, instead of solving multiple tasks in parallel. Don't jump to the next task unless you have thoroughly tested the current task and are sure there are no problems.

3. Know all the necessary theoretical knowledge before starting the task. Sometimes, you may not know what theory you need to learn, which is normal, so you need to ask others for help: programmer friends, mentors, or platforms like Dev Store.

4. You completed the task and gained experience points.

3. Not learning from the lessons

It feels good to successfully complete a task, but if you complete a task and then move directly to the next one, you have wasted a great opportunity to learn and grow.

After completing the task, make a summary of the task. For example, ask yourself the following questions:

1. What edge cases will cause my code to fail? Even if it doesn’t fail now, what application states could break the code?

2. Is my code clean enough? Is the code easy to understand and change for other developers, or even myself? Because you may need to fix problems hidden in this code or change the code according to other product specifications in the future.

3. Is my approach optimal? Are there other options I could use? What are the pros and cons of each approach? Is this task worth solving in a different way?

4. How does this module interact with other modules? Will it have a negative impact on other modules? Is it easily affected by other modules?

4. Not knowing how to overcome difficulties

There are two kinds of difficulty here. The first kind, you don't know how to solve.

You don't know where to start? You might try randomly or copy some code from somewhere else that you don't understand. However, this is not helpful. Even if the code you copied works, it's useless because when you encounter a similar task again in the future, you still can't solve it.

If you want to solve the task properly, then first you have to know why you are stuck. Here are some possible reasons:

1. Not mastering these theoretical knowledge well:

Language grammar.

How a library or API works, how a specific method or class works.

Programming paradigms (e.g. asynchronous programming).

System operation (for example, HTTP requests are key to understanding web development).

If this is the case, you can review the theoretical knowledge. If you are still confused, you can also seek help from someone.

2. If the task is too big, break it down into smaller tasks.

3. It may also be because you read too fast and ignored some concepts that you thought you were familiar with but were actually specious, so you were unable to understand the task requirements.

The second is that you know how to solve it, but the solution doesn’t work.

This is the most common situation in programming, even for experienced programmers. The best reason why your solution doesn't work is probably because there is a bug in your code.

How to fix it? The way is to debug the code. This is also one of the most important skills to learn as a programmer. It is not something that can be done casually or played a lucky guessing game. There are specific steps on how to find bugs. And many books teach this skill.

Unfortunately, this is the hurdle where many new programmers lose motivation and give up. Few courses explain the importance of debugging. If you don't know how to debug properly, it can be an insurmountable hurdle.

Many people worry about spending too much time debugging their code. This is normal and unavoidable in your first year of programming.

You even have to learn to like debugging. Think of it as an opportunity to fix errors and improve your programming skills. When you solve a bug, ask yourself this question: "Why did I make this mistake? How can I prevent it from happening again in the future?"

Another good idea is to write down the bugs you find in a programming diary so that you can summarize and learn from them.

5. Not knowing how to use resources

When you are learning to code, or debugging code, there are many materials you can consult: books, courses, tutorials, mentors, developer communities, and so on.

The most common problem when you study these resources is that you don’t fully understand what’s going on behind the scenes or how the concepts fit into the bigger picture.

Let's take a simple analogy: you spend 10 hours on a problem, and finally someone provides a solution. You tend to use it without thinking too much. However, there are many disadvantages to doing so. I suggest that after solving the problem:

1. Think about your previous thought process. Ask yourself what you did wrong and what aspects of your previous thinking that are worth learning from and improving for this particular solution.

2. Ask about the other person’s thought process. How did he/she solve the problem? Learn from the other person and absorb their experience.

If you are careful enough, you may find that these five obstacles are linked together, covering the entire process of being a programmer from entry to advancement. As a programmer who is preparing to get started or has just started, you may not have touched many of these points yet. But having a prior understanding before will be very helpful for you to avoid detours in your subsequent learning and growth.