Pitfalls to avoid when starting programming
Your very first year or two is one of the most crucial times in your programming career. This is why paying attention to how you approach those first few years is vital. When you first start your programming journey, you are guaranteed to make mistakes no matter what. Whether it is an embedded application or website development, you will avoid the headache if you know about some common mistakes. They can even make or break whether you stick with it and form a successful programming career or if you decide that it isn’t for you and move on to something else. The most common mistakes that beginners make are often the first ones to go, and understanding what they are and how to prevent them helps speed up this process.
Never Asking for Help
Knowing when you can’t do something and should ask for help is essential in programming and life as a whole. As a beginner, you simply aren’t going to know what to do all the time, and sometimes you won’t even be able to find a tutorial to help you out. In those situations, the best thing to do is to ask someone who has a coding career of their own and knows what they’re talking about. Finding such a person can be difficult, and you might have to look around a bit and meet some new people, but it is worth it. Having a real, live human being that knows what they’re doing can be an invaluable resource in situations where you get stuck and can’t find a way out.
Focusing Too Much on Perfection
It can seem like your finished program should always be perfect to a beginner: no bugs, no unadded features, and no errors. However, many programs that you run into on an everyday basis aren’t perfect at all. As long as the parts that people use the most are well polished and don’t break, it’s okay not to hunt down and fix every edge case for your program. Often, it’s outstanding to do 80% of the work, in which the other 20% is stuff people don’t use, so it’s not that important to get those things 100% right. In many cases, it simply just isn’t worth the effort. So, if you are starting, don’t worry so much about ironing out every fold and wrinkle, and focus more on the program as a whole.
Not Being Okay with Failure
Failure never feels good, but that doesn’t mean it isn’t. When you program, the first run of your code will seldom go well. Even after hours and hours of debugging and adding features, the programs you make will rarely be 100 percent feature-perfect and bug-free. However, you shouldn’t see this as a negative thing. If your program were already perfect, you wouldn’t be working on it in the first place. If all of our programs were feature complete and we didn’t have any bugs, programming wouldn’t even be a thing. Many beginners don’t realize this and beat themselves up over something perfectly normal that benefits them in the long run. It is essential to understand that failure is a crucial part of programming, and most of the time, you will be failing when you do it, but it doesn’t mean that you aren’t improving.
Learning Theory Instead of Practicing
One of the most intuitive things to do when learning anything, not just programming, is online and looking for tutorials. This can be a perfect thing for programming, but it can also hinder your progress if you don’t use tutorials correctly. Many beginners to programming get stuck in something that has been dubbed “Tutorial Hell”, which refers to the phenomenon of watching tutorial after tutorial, only never to improve. This happens because there is a big difference between memorizing information and genuinely understanding what you are learning. There are many ways to go from memorization to understanding, but the best way is through frequent repetition and practice, and eventually, you will improve. When you genuinely appreciate what you have learned, you can use it in your projects, and it becomes a valuable asset in your toolbox.
Trying to do Too Many Things at Once
There is so much to know when trying to learn to program that it can be tempting to take on everything at once. However, when you are in the beginning stages of learning, it is more important than ever to focus on the fundamentals and become proficient with them rather than moving on to the next thing as quickly as possible. A typical example of this is trying to learn multiple programming languages simultaneously. Doing this might seem like a good idea at first, as being well versed in various languages is a hallmark of a good developer. Still, it makes learning both languages more complex and is almost always slower and less effective than just slowing down and taking the time to learn one language at a time. This concept also applies to most things in programming, so it is best to take your time.
Not Thinking Like a Programmer
Some of the biggest mistakes someone new to programming can make don’t have much to do with their code. When you program, the actual code itself is only the result of thinking, designing, and problem-solving, and if you are doing each of these things poorly, the code at the finish will always be sub-par at best. Therefore, one of the biggest mistakes that any beginner can make is not to plan their projects out beforehand. When you code, you are both solving problems and writing those solutions down in code, and when you do both at the same time, they both suffer. It is much easier and faster to plan a project, find each problem you need to solve, and think about each of them separately before touching the keyboard. Planning before you code leads to cleaner code, fewer logical errors, and saves time.
Not Writing Clean Code
Writing clean code that you can understand helps you in many ways, but many beginners often ignore it. Messy code makes your code harder to understand, and not understanding your code is a surefire way to make many mistakes. Naming variables and functions properly are one of the biggest keys to writing understandable code. When you name something in your code, it should clearly describe what it does and never be arbitrary. Commenting on your code is also a great way to help you understand it later. Comments should warn about possible errors and essential details in your code. Overall, writing code that looks nice and can easily be understood is a skill that not many beginners have, but it is one that they all should learn.
Not Learning from Mistakes
When faced with code that refuses to compile, many beginner programmers throw in the towel and delete and rewrite the code without understanding what went wrong. However, not understanding what is going wrong in your code can lead you to make the same mistakes repeatedly in the future. One way to efficiently learn from bugs and errors is to consistently write them down in a place you can access in the future. Whenever you run into a bug, write a detailed entry including the bug itself, the cause, how you found it, how long it took you to find the solution, and the lessons you learned from fixing it. By carefully analyzing your mistakes, you can make less and less of the same mistakes over time and improve your debugging skills faster than otherwise.
Not Understanding Borrowed Code
One handy way to help your process as a beginner is to borrow other people’s code from websites like StackOverflow or GitHub. Doing this can help speed up the programming process and expose you to new ways to solve problems. However, copying and pasting a website without reading the code or understanding how it works does not teach you anything. It can become a crutch that many beginner programmers use instead of improving their skills. When borrowing code from someone else, it is always best practice to try to read it and learn how it works to learn from it and use what you know in other projects you work on in the future. Reading borrowed code can teach you new things and improve your skills faster than if you don’t borrow code at all.
Not Taking Breaks
When trying to learn something as efficiently as possible, the most intuitive method is to work as hard as possible and put the most time and effort into it. However, this mindset can be very damaging to learning and is counterproductive in most situations. Taking a short break every once in a while improves your productivity by quite a bit. In addition, when confronted with a complex problem, taking a short walk improves your creativity and can make a solution more evident than it was before. As a result, people who take many short breaks are more productive, creative, and efficient. Thus, you should always keep in mind to take breaks whenever you feel stuck, not just when you program, but whenever you are trying to be productive in general.
Takeaway
When you make a mistake as a beginner programmer, the first thing you should do is find out what it is and do your best to fix it. However, you don’t always know what mistake you are making, or even that you are making a mistake in the first place. Trying to find what mistakes you are making that you don’t know about can be very difficult, but looking at the people around you and seeing their mistakes can help in this process.
