Coding Best Practices Every Developer should know

Writing code isn’t something you can be perfect at. No matter how experienced or skilled you are, there will always be room for improvement when it comes to writing clean code. While there are no hard-and-fast rules that could be associated with a good programmer, there sure are some generally known practices commonly found in good programmers.

Why Writing a Clean Code is Important?

In software development, a code written by you will be maintained, reviewed, and tested by someone else. Therefore, not only writing the correct code is necessary. But a code that is easily readable, efficient, maintainable, and robust also carries equal importance.

More like this:

In this article, we will go through some of the best coding practices that you could apply to become a better programmer. Whether you’re a beginner, a novice, or an experienced programmer, you will find yourself doing better once you go through these practices. So, let’s get started.

I- Comments and Documentation

If you are a beginner in the world of software development, commenting and documenting your code may seem pointless. However, it often happens that the code someone else has written will be maintained by you. Now assume that it is not adequately documented and includes no comments at all. It will get difficult for you to maintain that code. We even ourselves forget our logic. Therefore, for future purposes, comments and documentation are pretty important.

However, it does not mean that you should comment out every line of your code. Instead, the comment should explain why something is being done or the logic and algorithm behind it.

int i; // increment the variable

The above comment is stating the obvious. Therefore, you need to avoid adding such comments.
[adinserter block=”2″]

II- Code Readability

One of the fundamental coding practices is to make your code readable. A program that is hard to read creates many problems in testing, updating, understanding, debugging, and maintaining. There are various practices that you can use to make your code readable. Let’s talk about some of them.

Consistent indentation

Indent your code correctly, i.e., make a habit of using a consistent indentation. Moreover, avoid writing long horizontal code lines. Instead, break it so that it spans over multiple lines. It makes your code prettier and easier to read.

Variable naming

Using meaningful variable and function names is very important to enhance the readability of your code. Instead of writing an irrelevant variable name and using a comment to explain it, add a meaningful variable name that describes itself.


name1 = "Ashton"; //first name
name2 = "Agar"; // last name


first_name = "Ashton";
last_name = "Agar";


//this function sorts an array using the bubble sort
void sort(int unsorted_arr[]){
// code to sort


void bubble_sort(int unsorted_arr[]){
// code to sort

Consistent Naming Convention

Organizations and programming languages follow certain conventions while naming variables, functions, and classes, etc. For example, Java commonly follows camelCase (every word is capitalized in a multiword except the first one) and PascalCase (every word is capitalized) syntax. However, whatever you are following, you must be consistent in it.

[adinserter block=”2″]

Helper function

A function should contain the code for which it was created, i.e., you need to add separation of concern in your code. For example, a function that is intended for calculating the total price should not include the implementation of calculating discount. Instead, we should create a helper method for it and invoke it inside our main function to improve readability and separation of concern in our code.

The DRY principle

You should follow the DRY principle. It stands for “Don’t Repeat Yourself,” i.e., your code should not contain redundancy in logic or information. Repetition affects your code’s readability, creates problems while updating your code, and increases code lines, etc. Let’s take a simple example. Suppose you have an array of 3 integers, and you need to take values from the user. Now, consider the following code.

int numbers[3];
cout <<"Insert value 0"<<endl;
cin >> numbers[0];
cout <<"Insert value 1"<<endl;
cin >> numbers[1];
cout <<"Insert value 2"<<endl;
cin >> numbers[2];

As you can see in the above example, the same piece of information gets repeated multiple times. Instead, we can use a for loop to write a more concise code.

int numbers[3];
for (int i = 0; i < 3; i++) {
  cout << "Insert value " << i << endl;
  cin >> numbers[i];

Let’s take another example. Suppose you have multiple HTML files, and each file contains the same or almost the same code for the header and the footer. Now, here the information is getting repeated. Instead, you can create separate template files for the header and the footer and import them wherever you need them.

Avoid Hard-Coding

Being a beginner programmer, hard-coding of variables seems simple and an easy way out. However, they reduce the generalizability of your program. Imagine running a program that works only for single input or a few values. It is of no use. Therefore, you should avoid hard-coding whenever you can.

Reinventing the wheel all the time

Before implementing some functionality from scratch, you should check if there is already an existing solution for that. Often, these solutions, either from some third-party library or stand-alone, are efficient and very well-tested. Therefore, you can reuse them and save your time and resources.


In this article, we discussed some of the best coding practices that could help you become a better programmer and improve the quality of your code. However, this is not an exhaustive list as it is a vast topic and could not be covered in one article.