So I’ve been working on a software project of mine. I’ll tell you more about it soon enough, but for now, it’s enough to say that I’m writing source code that generates source code.
One thing I’ve noticed is variable declaration. There are 2 extremes.
One variable used multiple times
This is the memory-efficient version. If you need the use of an integer variable, you just declare one variable. For example,
int i; i = DoSomething() + DoSomethingElse(); DoAlpha(i); i = DoThis() + DoThat(); DoBeta(i);
That’s just for illustrative purposes. If you’ve written a fair amount of code, I’m sure you can think of better examples. Which are probably (and usually) more elaborate and lengthier.
The drawback to this is that the variable is temporary. As the code continues its execution, previous values stored in that variable are considered to be unimportant to future executions. That’s why the value can be discarded and the variable overwritten.
Multiple variables but one-off use
Then there’s the “declare as many variables as you can (or think you need)” method. For example,
int i1 = DoSomething(); int i2 = DoSomethingElse(); int i3 = DoThis(); int i4 = DoThat();
This has the advantage of keeping the variable values “alive” through that section of code. The drawback is that you use more memory, even if seemingly trivial. I mean, that’s like 12 more bytes of memory (assuming integers still take up 32 bits when you’re reading this). That hardly makes a dent in the computer’s memory space.
The hybrid
The above 2 are extreme cases. What happens when you write code is probably a hybrid, somewhere in between the 2 extremes. For example,
int iSubtotal; int iTotal; iSubtotal = DoSomething(); iTotal += iSubtotal; iSubtotal = DoThis() + DoThat(); DoSomethingElse(iSubtotal); iTotal += iSubtotal;
You know what you declared those variables for, so you have an idea how many “unique” variables you need. This have the benefits of using the least number of variables (sort of), balanced with keeping the least number of “live” variable values around.
So why am I talking about this?
Auto-generated source code cannot generate hybrids
When you’re writing code, you have one very important advantage: You have context. A program that generates source code, such as a decompiler, does not have that.
When you’re writing code, you make variable decisions such as naming, naming conventions, how many you need and so on.
A decompiler has difficulty making decisions like those, so it has to choose one of the extremes. Typically the multiple variables route, because that’s the safest. All a decompiler can do is detect that a variable is needed, and so writes out the variable declaration in the resulting source code. It cannot decide on whether this part of the code can reuse one of the variables it has already declared (or at least has difficulty doing so).
Ok, so the cat’s out of the bag. I’m writing a decompiler. That’s not exactly true but will suffice for now (I promise I’ll tell you more soon!).
Anyway, that’s what I discovered while working on my software project. I have decided to go the multi-use variable route, because of a human (and programmer) behaviour. A human programmer has difficulty holding on to many separate variables in his head.
When a section of code requires many variables, I tend to try to limit the number of variables I remember in my head. Maybe there’s a pattern. I might remember there’s fFinancialYear1 up to fFinancialYear7. I might decide to refactor the code such that I only need one fFinancialYear floating point variable (assuming the appended numeral makes sense, and not just laziness in naming). I might separate the code section into several sections, so each section has a limited number of variables.
Maybe that’s not how most programmers work, but I find it “friendlier” than having thisIsAnAwesomeClass1 through thisIsAnAwesomeClass20, and I can’t remember which awesome class does which. I tend to work with tighter variable names (where possible and logical), and write code that’s as tight in scope as possible. So the variable values can be discarded, which means I don’t have to keep track of whether that value is still needed, even if the computer doesn’t mind having to keep track of it.
So how do you write your code where variables are concerned?
Many times when we’re busy churning out code and worrying about the accuracy of our calculations, we can forget that ultimately our users are looking at the results. We have to care about how to present those precious calculations so our users can make sense of it.
So you’ve learnt a bit about 
Arrays offer a simple syntax to declare a series of variables of the same type with minimum work. Think of arrays as boxes in sequential order, where the boxes can only hold a certain type of item.
I'm a mathematician, programmer, writer, 
