Reuse of variables

Question

I had a question about code optimization. I assume that the more the code is dried, the faster the algorithm will be compiled and executed.

Starting from this principle, I have the habit of reusing variables already declared. A simple example to illustrate, in Javascript would do the following:

var variavel = "Maria, João";
if(~variavel.indexOf("João")){
   variavel = true;
}else{
   variavel = false;
}

console.log(variavel);

whereas the initial value of variavel will no longer be needed later in the code, I took it to reset true or false in another situation. Could have done so, declaring a new variable existe and keeping the variable variavel intact:

var variavel = "Maria, João";
if(~variavel.indexOf("Joao")){
   var existe = true;
}else{
   var existe = false;
}

console.log(existe);

This is just a hypothetical example, but consider an algorithm with hundreds of lines using this reuse of variables that structurally allow me to do this.

Without sticking to Javascript specifically, I would like to know about languages in general:

1. All languages (or most languages) allow this variable reuse?
2. This is good practice?
3. There is considerable improvement in resource consumption (memory, compilation, execution), i.e., the fewer variables declared, the better the code in terms of resource consumption or performance?

Answer 1

I assume that the more the code is dried, the faster the algorithm will be compiled and executed

This is not an absolute truth, the way most people who code in Javascript tend to slow the code down precisely because it is dry. It also occurs in other languages, but in JS it is usually worse.

From the point of view of readability should not reuse variables to do more than one thing, there is no benefit of performance if done well. But in the example it makes little difference because the name is already bad (I know it’s just example, but the question speaks in good practice and coding style, so the example is not good).

The first example is terrible for readability, any future maintenance tends to create some problem if it ends up needing the variable somewhere else and the programmer does not realize that it is reused.

All languages (or most languages) allow this variable reuse?

If the value is of the same type all allow, has no way the language understand its intention, there is no way the compiler know that it is a reuse. If it’s any other kind, just the language of dynamic typing allow.

This is good practice?

Many already know what I think about the subject and I have even lecture devoted criticizing good practices. But in general it should not do this, it is very difficult to justify the reuse of the variable, and I doubt that someone produces more than lame excuses or arguments without foundation to indicate the use. Of course, in a specific technology there may be something I don’t know beforehand that can justify.

There is considerable improvement in resource consumption (memory, compilation, execution), i.e., the fewer variables declared, the better the code in terms of resource consumption or performance?

The gain, when there is, will be derisory. In language of script the gain will be greater, however, is what I always say, who chose a language of this type does not want to save resources, otherwise made a wrong option and then everything will be gambiarra, already in language more systems or Nterprise They will have minimal or non-existent earnings, especially if the person knows what they are doing. The economy depends on the adopted technology and even on its version or some configuration.

In languages with scope correctly implemented the second example does not work either because the variable created within the if there is only there.

Answer 2

I assume that the more the code is dried, the faster the algorithm will be compiled and executed.

It already left of a wrong principle. There are several complicated algorithms that run fast precisely because they are sophisticated (e.g.: a sort algorithm that adapts to small, medium or large lists). And there are many lean but dumb algorithms that are slow to be simple (e.g.: a Bubble Sort, or a 1-line Fibonacci that uses two recursions and redoes an immense amount of calculations already made).

1. All languages (or most languages) allow this variable reuse?

Not. Languages with static types will not allow the variable to change type. Functional languages with a focus on immutability will require you to create a new variable instead of the old one. In Erlang, for example, you will need to choose another name or use recursion. In F# you can do two or more Let x = ..., but they will be conceptually different variables (the last one hides the previous one).

2. This is good practice?

Not, not at all. If you have another concept, better use another name (therefore another variable). Perhaps it would be good practice on 8 or 16 bit processors. Today, no more. It would only be justifiable to do this if it were tested and proven that in such a program, in such a language reuse saves crucial bytes for performance.

3. There is considerable improvement in resource consumption (memory, compilation, execution), i.e., the fewer variables declared, the better the code in terms of resource consumption or performance?

Not also. Each variable can occupy a different amount of resources. It’s not going to be by saving variables that you will be able to improve performance, be it compilation, or execution.

Also, if you create small functions, you don’t have to worry about reusing variables, because anything you don’t return will cease to exist at the end of the function (or soon after, once the Garbage Collector runs)!

Remember that a byte does not occupy the same as an Object, which does not occupy the same as a Memorymappedfile or Socket, so the number of variables is the least important. In the case of files or sockets, what would save resources would be to close them (with .close() or something equivalent) as soon as they are no longer used. Reusing the variable would have a negligible effect, because what really consumes/releases resources are the procedures of opening/closing the files or connections.

Another example that explains why not reuse variables are the JITs: if the JIT compiler observes that you have only declared Function f() {...}, it can efficiently call the function with a few additional checks. However, if in the same code you do f = 1.0; or delete f; the code will need to be disoriented to first check the type of f, call it if it is a function or generate "f is not a Function" or "f is not defined" otherwise. This is one of the reasons why Javascript’s "use Strict" prohibits the programmer from redefining essential language elements (such as eval or arguments) and call delete in some situations. Very dynamic situations are a hindrance for optimizers.