This article highlights some common coding pitfalls that developers make. I’ll elaborate on it with a simple example.
$obj2->FuncOne( $obj1->GetData() );
$obj2->FuncTwo( $obj1->GetData() );
The result of GetData is passed to FuncOne and FuncTwo in two subsequent calls. What is the benefit of this approach? A simple answer is to save memory, by not using any variable to save the result. This argument was very strong until there were memories with very less capacity. But now even home user has a system with memory in GBs. So this practice is not good in today’s world.
So, what’s the drawback of this approach? Performance degradation. But how can it degrade the performance? Let me explain a bit. Consider a situation where GetData runs a query on database to fetch some data from multiple tables by joining them. Joins themselves are heavy by nature. So when GetData is called twice it will run query twice, and suppose that this code snippet is a part of a heavy process that can be called by multiple users on the web or in an enterprise application, just imagine what will happen to the database and application itself. The performance of the application will be degraded. Users of your application will get frustrated and at the end you will lose business.
Now let’s look at it from another perspective. This approach will also increase the CPU workload. When GetData will be called it will jump from one branch instruction to another and before that, it has to save the current address to the stack so it can pop it back when it returns back to the caller function. This has to be done every time when function is called. And when function performs heavy computation it needs more memory and processing power, increasing the footprint of your application and execution time. So you’re wasting your servant’s (CPU) time and energy by assigning it the same task twice.
Other drawbacks can be that code is more error-prone and is difficult to debug and troubleshoot, and code maintenance is high, especially when you have to modify the code to meet new requirements.
You can make your application and code much better and more efficient by adhering to a few simple best practices. In this case, the rule is that
“If result of a function is needed more than once then don’t call that function multiple times. Save the result of that function in a variable and use that variable instead. “
In view of this, the above code could be written like this.
my $result = $obj1->GetData();
$obj2->FuncOne( $result );
$obj2->FuncTwo( $result );
There is one extra line of code in the above example but is more efficient and much more readable than the previous one.
Let’s see another example.
my $result = $obj1->GetData();
$result = { %$result, %$someData };
$obj2->FuncOne( $result );
$obj2->FuncTwo( $obj1->GetData() );
In this example, the developer fetches the result, appends another previously obtained data, and passes it to FuncOne. Then he needs the same result, so he called GetData one more time. Now again, we can write this code in a much more efficient manner.
my $result = $obj1->GetData();
my $result2 = $result;
$result = { %$result, %$someData };
$obj2->FuncOne( $result );
$obj2->FuncTwo( $result2 );
Here we have saved another call to GetData, which might be performing some heavy computation or running a heavy query with joining multiple tables in it.
