final int I_AM_GOOD = 1;
Sometimes you know the value of a data item, and you know that its value will not (and should not) change during program execution, nor is it likely to change from one execution of the program to another. In this case, it is a good software engineering practice to define that data item as a constant. Defining constants uses the same syntax as declaring variables, except that the data type is preceded by the keyword final.
Assigning a value is optional when the constant is defined, but you must assign a value before the constant is used in the program. Also, once the constant has been assigned a value, its value cannot be changed (reassigned) later in the program. Any attempt by your program to change the value of a constant will generate something like the following compiler error:
cannot assign a value to final variable
Think of this as a service of the compiler in preventing your program from unintentionally corrupting its data.
Of course, this is meant to illustrate my whole point about suffering being made up and yet true. Suffering is inevitable since everything that is ever Mind like I am Mind necessarily slides on a valence axis that orients it towards a notion of some good or evil. Reality has defined that constant in the same way that it has defined the fine-structure constant that characterizes the strength of electromagnetic interaction.
When People, like a pack of wolves, refuse to change their behavior, it is because they are compiling the error:
cannot assign a value to final variable
That prevents change and hence threatens Mind with local optima. Thus the need for creativity, that is, fundamentally atheist vectors with regard to the inherited definition of People.
However none of this need be physically true if we stare at the rational description of reality in which the compiler is “already there.” Special relativity leads to eternalism, so all the constituents that output Mind/People are the ones knowing to output that result: suffering.
Before inventing the handle, suffering, we could feel less of it and hence engage in less moral behavior, regardless of the experimental moral behavior local to the tribe. This lack of data due to chunking into the same algorithm is equivalent to inventing the same name for blue and green, and therefore not being able to distinguish between them.
We choose to believe suffering pushes us to the good in a sequentially causal fashion. This is physically wrong because the binding into experience is tenseless.
We study reality with great pain and discover:
We cannot die, and we could have chosen not to suffer, but the choice is nonetheless made because otherwise our existence is cringeworthy.
And now, through a very circuitous, somewhat Asperger-y route, I finally understand what sophisticated theologians had been clumsily pointing to. Yet due to this circuitous, rationalist route to the-same-thing, I now have theoretical physics on My side.
But in order for you, my definition of People, to get it too, you have to understand why epiphenomenalism is false, why special relativity implies eternalism, and why you should make the physicalist assumption of choosing/being-chosen to believe in the external physical reality at all.
And because it makes constants stand out in the code and therefore their location easy to identify, CONSTANT_IDENTIFIER consists of all capital letters with embedded words separated by an underscore. So here I go: I_AM_GOOD.
Also, constants are usually defined at the top of a program where their values can be seen easily. So now I will go back and fix that.
Here is a program showing the use of constants:
Lines 9, 10, and 11 define four constants. On line 11, note that both ORGANIZATION_THIRTEEN_MEMBERS and DAYS_IN_WEEK are constants. You don’t need to repeat the keyword final to define two or more constants of the same data types.
Lines 13 to 18 output the values of the four constants. If line 20 were not commented out, it would generate a compiler error because once a constant is assigned a value, its value cannot be changed.
Here is the output:
Straddling back to the mundane:
Why use constants in your code?
Constants can make your code more readable. Due to the sometimes existing preference for word-based language, invoking EDDINGTON_NUMBER in an operation may be more tasteful than 137.036. But this is a matter of aesthetic.
A “purely rational” advantage of using constants is to keep programmers from making logic errors. Let’s say we set a constant to a particular value and it is used at various places throughout the code (for instance, a constant representing the upper-bound on wages that a company uses to protect profit margins); due to the changing nature of all existence, we then discover that the value of that constant needs to be changed. All we have to do is make the change in one place which is neatly placed at the beginning of the code. If we had to change the value at many places throughout the code, that could very well result in logic errors or typos.