9 Techniques to Write Your Code Efficiently

(Photo by Oskar Yildiz on Unsplash)

It’s really easy to write efficient and faster code. Efficient code, not just only improves the functionality of the code but it can also reduce the time and space complexity of the programming.

Speed is one of the major factors in deciding the quality of the code, for instance, your code might be producing the required result but it takes some time to execute then it will not be considered a quality code. An alternative approach to the same problem producing faster results will be considered better.

The code should be clean i.e. comprehensible and readable so that it can be reused (saving the efforts of rewriting the whole program from scratch), adding new features, and making the process of debugging more easier.

In this article, I will cover some simple tips and techniques which we can easily apply to make our code more elegant and efficient.

"There is always more than one method to solve the problem."

How to write code efficiently

Now let me show you how we can make our code efficient and faster.

1. Creating function

If your block of code is being repeated or it has a similar structure and it can be parameterized, generalize it by creating a function for the same.
Creating a function will be computationally cheaper and will create a much cleaner (readable) code as well.

Rather than writing the same code again and again, now we will just have to call the function to execute the code block.

2. Eliminate unessential operations

Processing of the same data, again and again, can be avoided by saving the required value in variables (for example- calculating the length of string, conversion of integer to string, etcetera). The data can be stored in a dictionary or an array for faster execution of code (elimination of recalculation of values). For example:

In the code above, the length of l will be calculated 100 times because of the for loop. This unnecessary calculation can be eliminated by storing the value in a variable.

Now, as we can see the calculation of length multiple times is eliminated. This method can be very effective for large codes.

3. Avoid declaring unnecessary variables

In a function, if we want to return a certain value, instead of storing it in a variable we should directly return it. For example:

Instead of writing the above-mentioned code this way, we can write it as:

This simple technique can make our code look cleaner.

4. Use appropriate algorithms

Selecting the correct algorithm for solving the programming problem is very necessary. Only an efficient coding style won’t make your code efficient and fast. Think of an algorithm that works with low time and space complexity even for large values.

5. Learn the concept of dynamic programming

Dynamic programming is an approach that can be applied to a certain class of problems (the problems which require the calculation of certain values multiple times, resulting in high time complexity of the code). This technique significantly optimizes the code and make it much more efficient.
Here the concept is to break the problem into sub-problems and save the result (store the values in a list/array or dictionary) for the future so that we will not have to compute that same problem again.

6. Minimize the use of If-Else

If-else approach is one of the most common and easy approaches to solving code-branching problems.

However, it results in less readable code and increases the complexity with any new conditional requirement implemented using If-Else.

The appropriate strategy should be applied to obtain an efficient code. Few of them are:

• Eliminate unnecessary else block- Understand this with the example.

Now remove else block from this code.

This code will work the same as the one above but here the else block is eliminated.

• Storing If-Else in a dictionary- This method can be used in the case where we have to perform an operation based on some condition and some more operations will be added later.

Here, if we want to perform another operation then we will have to add another elif(else-if)! This does not look like a nice approach. Now let’s try the same problem by using a dictionary.

This method eliminates the need for the If-Else statement!

In the above code, if and elif (else-if) conditions are stored in the dictionary and the value of variable_two are easily obtained using .get() (where the second parameter of .get() the function acts as else statement).

This approach makes the code look cleaner and easily readable.

7. Break the loops when necessary

The number of iterations of the loops should be reduced as much as possible. The loop should break when the required value is calculated instead of running all the iterations. For example:

As we can see in the above example, instead of running over all the iterations, the loop ends immediately after the required result is obtained. This will make the code efficient and computationally cheaper to execute.

8. Avoid declaring variables in the global scope

When you have to write a very large code (thousands or millions of lines), avoid creating variables and loops in the global scope, as they can create noise and influence code desirable.

We should write code inside functions or methods. And these functions and methods should be defined inside the class definitions.

This will make code clean and easy to maintain. Moreover, we should always add comments wherever necessary to make the code easily understandable and reusable for later use.

9. Keep practicing!

Somethings can only be learned by practicing. So just keep coding, you will definitely learn many things through experience that no one will ever teach you.

Conclusion:

These are some essential tips and techniques for any developer who wants to achieve mastery in their field. Implementing these basic rules at the right time can make your code much better and professional at the same time.
So now it’s the time to put an end to old practices and try executing new techniques to make your code efficient, readable, and maintainable to work with. 

Resources:
http://creative-punch.net/2014/02/3-tips-to-write-faster-and-more-efficient-code/
https://docs.oracle.com/cd/E80738_01/pt854pbh2/eng/pt/tpcd/task_WritingMoreEfficientCode-0749ba.html#topofpage