10 Most Common Programming And Coding Mistakes Data Scientists Make

This post may contain affiliate links and I may receive a small commission if you make a purchase using these links – at no extra cost for you. Please read my disclaimer here.

Data science is an emerging field, and there's a massive demand for high-quality data scientists in the market.

10 Most Common Programming And Coding Mistakes Data Scientists Make

Every company is looking for personalization, forecasting, clustering, and other such things to be implemented with their internal data. Data scientists perform such things, and they provide immense benefits to companies

Today, every company has data, but only some of them have the best data scientists.

Suppose you come from a software engineering background. In that case, you already have a head start against most other data scientists who come from statistics or math backgrounds and are gradually learning data science.

You can excel in this field if you don't make some common coding mistakes.  

Data scientists must be good in math and statistics, machine learning (ML), and data visualization using Python and R programming.

As we advance, you’ll come to know the common coding mistakes data scientists make.. As a business, before contacting developers for hire make sure they know all coding principles and don’t commit such common data science mistakes.

10 Most common programming and coding mistakes data scientists make 

1. Variable naming

Naming variables is a hard thing for every developer. Writing code is easy, but finding appropriate variable names is hard for many, and that drags them into creating bad variable names. 

Variable Naming

When creating a new variable, you should think for a moment about what the variable will store and give it a proper name. Some data scientists who come from different backgrounds make this mistake quite commonly. 

They use single-letter variable names, which don't serve any purpose, and every time they have to use such variables, they need to print and see the contents of such variables.

It is a bad coding practice and a huge mistake that can slow down your development.

Lousy variable names are a mistake that affects many people and not just you. When you share your code with everyone else on the team, they'll constantly ask you about the different variables and what they do.

Moreover, when you leave the position and hand over the project to someone else to maintain, you'll have to take longer KT sessions. 

On the contrary, all these issues can be avoided by using descriptive variable names in your code.

Understand the usage of a variable, and give it a commonly understandable name so that anyone who reads your code understands what precisely the variable holds and when it should be used in the project. 

Bad variable naming violates the KISS coding principle, and a good application is one that does not violate any coding principles, so stop naming variables as a,b, i, and j and use descriptive names for them

2. Little to no documentation

Data science applications are complex, and not everyone can understand them completely, but you should not make them harder.

Many data scientists do not understand the power of documentation and just keep on writing code for a long time. 

Documenting the code properly is very important. You should try explaining everything your code does to make it usable for all.

Instead of sitting to write the documentation at the end of the project, it is better to write explanatory comments at all stages and explain the program as it flows

This helps you grasp the concept better, and you can explain your thought process easily. 

Every function you write should have some comments accompanying it. The comments should explain what the function does, what inputs it expects, the data types of the input, and the output it gives.

If you do this much documentation for your code throughout the project, you’ll never have to explain anything to anyone. They can just read the comments and understand the entire project. 

But beware, don’t write a comment for every line of the code. It is unnecessary and just makes your code too lengthy

You don’t have to explain the very basics of your code. Just make sure that you document it enough that the next person who reads the code understands why you wrote that code by just reading the comments. 

3. Relying on Jupyter notebooks

Jupyter notebooks are great, but they still lack many excellent features that can help you work faster and better

Relying on Jupyter Notebooks

Data scientists love Jupyter notebooks to perform all sorts of work, and it is because everyone learns data science by using jupyter notebooks only. 

But there are better options out there that should not be missed. Jupyter notebooks are suitable for smaller and independent work, but in a professional setting, you should use better IDEs.

IDEs have tons of plugins and other features that increase your efficiency. 

IDEs have better programming language support, in-built terminals, code optimization suggestions, and other such things that help you write better code and collaborate with others easily.

By using an IDE, you can standardize coding policies on the project and create rule files that enforce coding standards across the team. 

Relying too much on jupyter notebooks is a bad thing, as it does not promote following the best coding standards and software engineering practices

Using it for a long time will change your approach to just getting the work done without following any standards, which is detrimental. 

Become a good data scientist by learning new IDEs that are helpful, and stop using Jupyter notebooks for everything you do. You’ll see a significant boost in your productivity and efficiency if you make this switch. 

4. Not backing up code

Backups are the most important part of any data science project. Data scientists often forget to back up their code and then go on to write everything from scratch again if they lose the files. 

Backups help you preserve working code that is used somewhere, and they allow you to reuse your previously written codes

If you ever accidentally delete a file or the file gets damaged due to some reason, a backup can come to the rescue and provide you with a workable version of the file.

To back up your files and have versioning benefits, nothing is better than Git.

You can download Git, install it locally, and create a version control workflow for your data science project files, but ensure that you don't commit very large files in this workflow. 

If you are using Git, it is better to use GitHub too. It is a remote repository where you can store your code and collaborate with others. Storing your code in such repositories ensures that your code is never lost, even after some failures. 

5. Writing algorithms from scratch

Many people think that the identity and competencies of a data scientist should be measured by the number of algorithms they can write from scratch. But it is a huge mistake that many data scientists make on a regular basis.

Writing Algorithms From Scratch

Today, you don’t have to worry about writing algorithms from scratch. There are multiple versions of each algorithm packed in libraries that are just one command away. 

By writing algorithms from scratch, you end up spending too much time on each project and delaying the results

Such an approach is actually flawed. Instead, you should understand the working of major data science algorithms, find out the libraries where they are already implemented, and understand their use cases.

Once you've done the above things, you can go on working and then choose the best algorithm that matches your use cases to create models. 

This improvised approach saves a lot of time in data science projects, and it also provides you with more accurate results on your work items

So, if you are doing general data science tasks, stick to the already implemented algorithms rather than creating one for yourself from scratch. 

6. Not hiding data & other things while sharing code

Data science projects need to be shared with various people for validation and presentation purposes, and it is quite normal too.

Many data scientists forget to hide their data or other secret information while sharing code, and the results of such mistakes are devastating. 

Always make a habit of hiding secrets in your data before you share the code with anyone. It will restrict people from using your code and also save you from breaching data usage policies. 

An example of such a thing can be when you are performing some data science task based on user data, and you forget to mask PII before sharing the observations with someone.

7. Relying only on one package or language

Being too dependent on one thing surely has detrimental effects. As a data scientist, your goal is to achieve the outcomes that make business decision making or other important tasks easier, and not to preach a language or package.

Relying only on One Package or Language

There are thousands of data science libraries, and many of them are overlapping. You can get implementation of the same thing in multiple libraries, and you have to be flexible enough to quickly adapt to newer things

If you build a high dependency on the same package or language, you may miss out on some features that are important for your implementations, and go through the hard way.

But be open to experimenting new languages and packages to get the desired output, and you’ll see a great progression in your knowledge, and how fast you come up with the output for business teams.

8. Not paying attention to warnings

Language creators have placed warnings for a reason, and they should be taken seriously.

Warnings represent some flaw in the code, or execution that is not a big issue, but it can change how your code works

As developers and data scientists, we often think that getting an output from the code is much more important, and warnings can always be ignored, but that is not the case.

When there’s a warning, there is definitely something wrong. It may produce good output for the time being, but once there’s a slight change, your output will be distorted, and you’ll have to look for newer ways.

There are different types of warnings that you’ll come across, and you should always pay attention to them. Every warning comes with an explanatory name, and some explanation that can help you dive deeper into the problem, and fix it easily.

While writing any code for your projects, always remember that fixing a code that has warnings is much easier than fixing a code that has errors. So keep an eye on warnings, and avoid the mistake of undermining them.

9. Not using type annotation

Python is not a statically typed language, and this means that type checking is done only at the run time.

Not Using Type Annotation

But this introduces a new problem of just assuming variable types.

When working on important projects, and in teams where code is being shared across, not having type checking, and just assuming on types becomes a big issue.

A way to get rid of this issue is to introduce type annotation in your code. Type annotation is a way of labeling input-output parameters of a code piece.

When you define a function, put a label/hint in the parameter list against each parameter which shows the data type of the parameter. In the end, you can also show the return type of the function.

By doing this, you can decrease unrelated calls to the function, and make it easy for others to understand your code and use it effectively.  

Type annotation is pretty simple, but the benefits are immense. You’ll thank yourself that you stopped making this mistake in the long run when your projects become complicated.

10. Not following PEP standards, and conventions

Python was not invented as a language that was just there to do things in an easy way. It has a much larger objective than this, and there’s a bigger vision for the language from the creators.

Most data scientists make many mistakes in writing python code, which makes the code look ugly, unreasonable and poor at performance and execution. Moreover, such bad code violates many standards and coding conventions too.

Python has its own PEP standards, and conventions that act as a guideline, and following them gives good results.

So don’t make the mistake of writing ugly Python code, rather follow the PEP conventions, and write Python code that is optimized, useful, and relatable forever.


If you are new to working on data science projects, you might make some of the above-discussed mistakes, but now as you know these coding mistakes, make sure to avoid them in future projects.

Incorporate coding standards, and you'll directly eliminate many of these coding issues. Data science is about being better than yesterday, so you should keep checking your mistakes and stop making them again.

About the author 

Peter Keszegh

Most people write this part in the third person but I won't. You're at the right place if you want to start or grow your online business. When I'm not busy scaling up my own or other people' businesses, you'll find me trying out new things and discovering new places. Connect with me on Facebook, just let me know how I can help.

{"email":"Email address invalid","url":"Website address invalid","required":"Required field missing"}