Mistakes to Avoid while Learning Programming

ishant

Everyone begins their journey with programming somewhere, and if you’ve started on the path, congratulations! You’re already one step ahead to becoming a skilled developer.

Programming gives you the power of writing your vision into something that the computer can execute. If you’re not having fun while doing it, you’re most likely doing something wrong. But don’t worry, you’re not alone. We’ve all been there!

When most people start out with learning their first programming language (or languages, but wait, we’ll come back to that later), there are some common mistakes that they make. And these mistakes can really make the overall process of learning and coding a lot less enjoyable for you.

So, let’s take a look at five common mistakes that beginners in programming make, and how you can identify and rectify them early on to make sure that you have fun with programming — just like it’s supposed to be!

1. Trying to Learn Multiple Languages at Once

When you’re just starting to code, not sticking with one language can be one of the worst mistakes you make. While it is definitely possible, and many people might actually recommend it, learning multiple languages can actually give you a lot of frustration.

There are a lot of concepts that differentiate one programming language from the other, e.g., C is a low-level procedural language that involves ‘;’ to end statements, Python, on the other hand, is an interpreted high-level object-oriented language that uses indentation.

Apart from differing in how they’re oriented and other concepts involved with the languages, they also differ in syntax. Keeping up with these differences while also trying to learn can confuse you and significantly slow down your learning curve, given you’re a first-time programmer.

A better approach is to learn your first language and gain proficiency over it. After this, you’ll automatically gain the confidence to start with a new language(s), and it’ll be easier for you since you’re already comfortable with basic programming concepts.

Also, if you first learn to program in a low-level language such as Java, C, or C++, then learning high-level languages is going to be a cakewalk, because now you understand the underlying architecture of how things work closer to the machine.

All in all, sticking to one language and mastering it when you first start to program will benefit you in two ways: having good command over the language as well as the confidence to learn other languages after.

2. Coding Without Planning

It sure is tempting to dive right in after looking at a problem and start writing the code. But, by doing this, you’re setting yourself up for logic errors and hours of rewriting the code which could’ve been avoided if you planned the program beforehand.

Whether it is a small coding problem or an elaborate project, planning on paper before you actually start coding can help you analyze the cases you might have overlooked and help you avoid logic errors that arise from diving right into the first solution that you come across.

The aforementioned “planning” can be as simple as rough pseudocode of the coding problem or a general workflow of the project. Try breaking the problem into parts, so you can deal with them individually. Instead of starting off with the first solution you come across, think of other possible solutions that might exist. Analyze which one works better given your constraints.

You don’t have to get every last detail right. Be flexible — your original ideas may change. The important thing is to get a clear high-level idea of how your program will work. This will not only save time but also give you the liberty to explore and analyze multiple methods and cases to solve the problem.

3. Not Writing Clean Code

We get it. When you first start out writing code, the prime objective is to somehow make it work and get the desired output. But, apart from writing code that works correctly, you also need to make sure that it is quality code.

This includes everything from formatting your code correctly, using meaningful variable names, and commenting here and there to make sure that when you revisit the code, it still makes sense.

Also, you might have to work on a collaborative project in the future which could involve going through and debugging others’ code. Imagine how hard it would be to try and understand the other person’s logic while dealing with code that’s messily written.

“Any fool can write code that a computer can understand. Good programmers write code that humans can understand.” — Martin Fowler

Your code should be easy to read, easy to understand, and easy to change if needed. Some simple ways to do this are:

Use intention-revealing names for variables and functions. For example, instead of declaring the number of students in a class as ‘x,’ declare it as ‘students.’ While writing a function to calculate the factorial of a number, call it ‘fac()’, or ‘factorial()’ instead of arbitrary names like ‘func’ or ‘func1’.
Comment wherever necessary, but do not overdo it. Make sure to add comments explaining your intention. Warn of consequences, possible errors, and important details. For example, // this script will take a very long time to run.
Write code that looks pleasing to the eye. Now be honest, would you ever want to go through a clump of arbitrary statements all written in a single line? Trust me, it is every developer’s nightmare. To write code that looks good and easy to read, ident blocks of it, use whitespaces, and always change lines after statements.

4. Not Writing Reusable Code

There is a golden rule when it comes to programming — If you have to repeat your code multiple times, there most definitely exists a better way to write it.

Efficient coding involves writing and using reusable code. The more you can reuse, the less you’ll have to write every time. However, for beginner coders, writing reusable code can be tough to wrap their heads around.

You might look at your code and think everything you’ve done is a one-off situation and none of it will be needed again. But the trick is to break it down into smaller chunks and look again. Look for the little things that seem simple but need to be done all the time. Maybe they only take a line or two of code, but these small things add up over time.

Two simple ways in which you can ensure the code you’re writing is reusable are:

Not using hardcoded variables/“magic-numbers”: The only time it is ever OK to hard code values into your program is when they are constants. And in this case, you should make it obvious that the values are constants by using constant identifiers. Apart from this, always call these values dynamically by expressions or user prompts in case they need to be changed. This can ensure that your program works not just for a given set of values, but for all values in the acceptable domain.
Write general functions instead of those that are highly specific: The first rule of writing a function is that it should do one thing, and only one thing. If you write a function that does a bunch of things that can only apply to a single situation, you’ve just wasted your time writing something that cannot be reused. Instead, break down the problem into smaller bits and write functions that either return a value, or change the state of an object, but not both. This not only makes those functions reusable but also makes it easier for a random programmer to grasp the intent of the functions, make test cases for them, and modify if necessary.

5. Duplicating Someone Else’s Code Instead of Figuring Out What’s Wrong With Yours

You code a problem and a bunch of errors show up. Even after rectifying the syntactical errors, you’re stuck with code that doesn’t work, and worse, you have no idea why.

Facing a blockage due to this logic error — and after spending hours on it in frustration — you decide to Google the problem and try duplicating another approach instead.

Now, while there’s no harm in trying out different methods to get the output, leaving logic errors unresolved can set you up for many similar blockages in the long run.

After all, your approach is where your mind went first. And so, it is very important to be aware of what exactly is wrong with a particular approach and why it can’t be used, so that when you encounter a similar problem in the future your mind will know in which direction not to go.

When your code doesn’t work, don’t leave it until you figure out why it doesn’t give the desired output. After all, learning is not just about finding solutions that work, it is also about identifying those that don’t and knowing why.

Always remember, making mistakes is a part of learning. What’s important is to identify and rectify them as soon as you can. Make sure that you adopt good coding practices early on. Write quality code, practice consistently, and keep learning.

Happy coding!