10 Mistakes Most Computer Programmers Make

1. Reinventing The Wheel

Suppose you need a sub-routine for calculating the average of 5 numbers. That’s easy. But you still shouldn’t write because you’ll easily find an existing function that achieves this. As a programmer, your goal should be to find existing functions when possible and only write code when you have to. 

The benefit of this approach is that it saves you both time and effort and lets you fast-forward progress. Writing everything yourself from scratch just results in spending more time and energy than necessary. 

3. Bad Commenting

Good comments are an excellent way to explain your code’s purpose. Good comments are written in everyday language, and they simplify the complex workings of your program. Using good comments provides you with multiple major benefits. 

Firstly, comments are the easiest way to explain what a section of code is for. Other devs and team members that you’re working with can immediately use them to understand your work. That saves everyone time and effort. 

But, it’s important to have good comments. A successful programmer writes short, concise, and specific comments that easily outline what a section of code does. Your comments shouldn’t be long, bloated, or irrelevant. 

5. Do Not Use Source Controls And Backups

Imagine writing 1,000 lines of code and then losing it all because your laptop accidentally shuts down. That’s literal hours and hours of effort that goes down the drain. Unfortunately, this is an all too common experience for many amateur programmers who neglect source control and backup. 

You need to constantly save your code to ensure it survives any technical problems. You shouldn’t treat your program differently than any other valuable data. Your code should always be saved and backed up to ensure you never lose it. 

7. Not Following DRY

DRY stands for ‘Don’t Repeat Yourself. It’s a general programming principle that says you shouldn’t copy-paste sections of your code. If you find yourself doing this, you should build loops and functions instead. 

The reason why you shouldn’t commit DRY is that it wastes time and energy. It’s also a bad long-term habit that’ll hurt your projects with bloated and unnecessary code. Always remember, that every line of code in your program should have an authoritative and unambiguous purpose. 

9. Picking Trendy Stacks Instead Of Practical Ones

A good technology stack is an asset. Conversely, a trendy one is likely to be a liability. Never choose a technology stack just because it’s trendy. An unoptimized stack for your needs could lead to a bloated and unusable program. 

Instead, as a professional programmer, you want to select a technology stack that meets your exact needs. Examine every item in your stack and objectively ensure there isn’t a better alternative. 

Optimizing your stack will have long-term practical benefits, including better functioning programs and fewer problems. 

2. Not Making A Proper Plan For Your Project

You’ll virtually never hear any successful programmer say they follow an ad hoc approach. 

Like any project, building software needs proper planning. Successful programmers create an entire plan for their project before typing the first word. The benefit of doing so is that it simplifies the entire process. A plan displays everything you need to do to finish your project. 

In contrast, you’ll have a slow and inefficient experience if you write a program ad hoc. If you don’t use a plan, you’ll most likely create a bloated application with incomplete features and functionality issues. 

4. Using Bad Variable Names

Variables are a staple in every programming language. Every programmer uses them to meaningfully designate important inputs and metrics in their code. So, it’s important for variable names to actually be meaningful. 

Successful programmers use short and accurate variable names, like ‘gender’ instead of ‘M/F.’ ‘Gender’ effortlessly communicates what the variable is. It’s a boolean that can be male or female. Whereas out of context, ‘M/F’ could be interpreted in multiple different ways. 

Successful Computer programmers always choose the simplest and most straightforward variable names, while amateur ones use long and confusing ones. 

6. Overloading On Languages

This problem is specifically for younger developers. They’ll spend an enormous amount of time debating which programming language they should use. JavaScript, Python, C, or C++? They’ll also spend endless hours debating which framework they should use. For instance, SQL or SQLite for a database? 

Most programmers don’t need to think this hard. Programmers are problem solvers. As long as they know their basics and understand how to write code, it largely doesn’t matter what language they choose. They just need to pick a lane and stay in it. 

8. Writing Complex Code For The Sake Of Complex Code

Programming is all about building the simplest solution to complex programs. It’s always better to write the fewest lines of code to solve a problem. Simplicity is great because it makes your program easier to execute, understand, and debug. 

Yet, it’s all too often that amateur programmers write unnecessarily lengthy and complicated programs. These programs take longer to write, are harder to debug, and can be a nightmare for anyone else to understand. 

Always choose the simple solution if it delivers the same results as the complex one. 

10. Not Having Fun

Programming is a tough job. You likely work long hours, have difficult projects, and have short deadlines. It’s hard to have fun under these working conditions, but it’s important to enjoy yourself nevertheless. Failing to enjoy your work leads to quick burnout. 

You’ll find no shortage of programmers online who’ve had their passion for coding sucked out of them. You don’t want that for yourself. You want to build a sustainable work ethic that provides you with enough enjoyment that you can realistically work long-term.