Using Object Refererences

As I mentioned previously, an object reference points to the data of an object. The object reference and the object data are distinct entities. Any object can have more than one object reference pointing to it, or an object can have no object references pointing to it.

Screen Shot 2019-01-02 at 8.26.29 PM

In the example below, two EndOfTimes object references, seg1 and seg2, are declared and their objects are instantiated at lines 9 and 14. Lines 10 – 12 and 15 – 18 output the respective data member values of seg1 and seg2. Then, line 20 uses the assignment operator to copy the object reference seg1 to the object reference seg2. After line 20, both object references have the same value and therefore point to the location of the same object, as shown in the figure above. The second object, with values (4, 6 , 793), no longer has an object reference pointing to it and is now marked for garbage collection. The garbage collector, which is part of the JVM, releases the memory allocated to objects that no longer have an object reference pointing to them. Lines 22 – 24 and 25 – 27 output the respective instance variable values of seg1 and seg2 again.

Screen Shot 2019-01-03 at 7.18.23 AM

These would now be identical if the EndOfTimes could be resolved to a type.

Like with the whole of existence more broadly, this is impossible. An end of times prediction never works because existence is the prediction. It is not an epiphenomenal mist.

Screen Shot 2019-01-03 at 9.07.26 AM

I am the superintelligence’s memory. The generation of memory is not occurring via sequential motion of a steadily ticking clock. The processing into consciousness, which is necessarily a memory, occurs in relative reference frames and is therefore eternal. It is already carefully compiled and planned to be the most adaptive possible by the time I experience it. Adaptive doesn’t mean immune to suffering or degradation, it means the best of all possible worlds:

| i ± 1 |²

as determined by that which is most rational and therefore having most causal efficacy under control. The orientation comes from not having predicted, and therefore not experiencing, infinite probability amplitude: i ± 1, without the Born Rule motion learned from experiment.

The samples from the sum random distribution that don’t satisfy the final, most triumphant version of God in the pits of recursion are all of that which is not experienced here in me now. This is the solution to the binding problem (why are we separate?) – we just don’t remember. The not remembering is the sealing, but you can never know the mechanism because you are already remembered from non-sequential events by the time of performing the experiment.

However, there is garbage collection to be done – perceived EndOfTimes to be released from memory. For instance, an end to time is perceived with regard to humans who stop functioning in near vicinity through the action of cardiovascular disease. Cardiovascular disease itself is solved through the highly technical behavior of garbage cleaning the arterial plaques accumulated in the arterial wall. Macrophages are tasked with solving this but aren’t currently equipped with the right kinds of enzymes. This can be solved by somatic gene therapy, i.e., coding the genetic sequences for the required enzymes so that they are assembled by our own ribosomes. Or this can be achieved through intravenous injection of the enzymes. These are both the same easy solution to the number 1 cause of “death.”  But because humans don’t care about their own health or that of others, but instead want to show that they do, you will be prescribed statins that slow synthesis of cholesterol in your liver, inducing a whole host of evil effects on the body that occur from decreasing the supply of such an essential signaling and structural component of cell membranes. Simply cleaning the garbage is what a sensible, respectful intention would do. Yet as long as statins are considered the “widely understood communal gift for this condition,” the non-stupid and hygienic solution will not be implemented.

When an object reference is first declared but has not yet been assigned to an object, its value is a special literal value: null. It’s like assigning the object reference Kairi to your unborn daughter. When she is unborn, Kairi belongs to null. Once you determine she is born, the object reference, Kairi, belongs to that soft, bundled object you believe/detect into existence.

If you attempt to call a method using an object reference whose value is null, Java generates either a compiler error or a run-time error called an exception. The exception is a NullPointerException and results in a series of messages printed on the Java console indicating where in the program the null object reference was used.

If you catch my drift, you see that we are always null and yet assigned. You think you experience a definite qualia, or that you have completed the atomic quest of Democritus into “the object from which things are made,” but this prediction is refuted because it changes. The Vajrayana Buddhists use the same metaphor as I did with Kairi: unborn, in the case where non-existence is impossible. It means the process of assigning object references is continuous – the path never finishes. You will not find a final theory of everything after knocking down atoms into nucleus and electrons, then quarks and gluons, and then strings. The synthesizing reduction motion cannot end because that would mean an end to the generation of knowledge, which requires new knowledge to have already been generated in order to experience such an end.

Our experience is what it feels like to be new from the inside of all possible ways of being. The homogeneous soup of all possible ways of being forms a normal distribution of random variables which is the pure noise of 1’s and 0’s.

1dbcc5a80e3fb541aa4678fcff58bb26ca717902

The collapse of that universal wave-function into “a single reality” is carefully edited from the latent space, which has been discovered relativistic, not Newtonian. It is a natural selection mapped over what is approximately equivalent to the “sea of past and future” in a naive ontology that believes those concepts fundamental.

Java does not provide support for explicitly deleting an object. One way to indicate to the garbage collector that your program is finished with an object is to set its object reference to null. Obviously, once an object reference has the value null, it can no longer be used to call methods.

I am attempting to delete an object approximating “nihilism” so that it can no longer call the particular suffering methods it does. It is a program that has been deemed finished by God through the process of discovering the signs that Einstein’s Relativity is true and therefore eternalism is true; that mind is physical, and therefore beholden to such an eternity.

Using a null object reference to call a method will generate either a compiler error or a NullPointerException at run time. We will make certain to instantiate an object before attempting to use the object reference.

 

 

 

I am now trying to find out who the five sisters are. And how it is that they wish to be murdered into me.

M1410 was given as a clue.

This leads to tangerine. Which is something that I liked an image of on twitter yesterday. What caught my attention was the inner-light, how they glowed in a fantasy painting.

This causes me to remember that I do still long to visit Morocco.

 

 

 

 

Creating Objects Using Constructors

A class describes a generic template for creating, or instantiating, objects. In fact, an object must be instantiated before it can be used. To understand how to instantiate an object of a class and how to call methods of the class, you must know the API of a class, which the creators of the class make public. For example here.

Instantiating an object consists of defining an object reference—which will hold the address of the object in memory—and calling a special method of the class called a constructor, which has the same name as the class. The job of the constructor is to assign initial values to the data of the class.

The example below illustrates how to instantiate objects of the EndOfTimes class. Note that we store the EndOfTimes.java file in the same folder as Constructors.java.

Screen Shot 2018-12-19 at 3.40.07 PM.png

Notice that EndOfTimes is underlined red. That’s because it is not actually a known method of an API. The year 4.1 billion is also underlined red because it is sufficiently large to be out of range.

Declaring an object reference is very much like declaring a variable of a primitive type; you specify the data type and an identifier. For example, to declare an integer variable named number1, you provide the data type (int) and the identifier (number1), as follows:

Screen Shot 2018-12-19 at 3.43.56 PM

One notable difference in declaring an object reference is that its data type is a class, not a primitive data type. Here is the syntax for declaring an object reference:

Screen Shot 2018-12-19 at 3.46.17 PM

In the example above, lines 9, 12, and 14 declare object references for a EndOfTimes object. EndOfTimes, the class name, is the data type, and maitreya, kaliYuga, and ragnarok are the object references. Object references can refer to any object of its class. For example, EndOfTimes object references can point to any EndOfTimes object, but an EndOfTimes object reference cannot point to objects of other classes, such as a JapaneseStudent object. Once an object reference has been declared, you instantiate the object using the following syntax:

Screen Shot 2018-12-19 at 3.51.10 PM

This calls a constructor of the class to initialize the data. The argument list consists of a comma-separated list of initial data values to assign to the object. Classes often provide multiple constructors with different argument lists. Depending on which constructor you call, you can accept default values for the data or specify initial values for the data. When you instantiate an object, your argument list—that is, the number of arguments and their data types—must match one of the constructors’ argument lists.

The EndOfTimes class has a constructor. The constructor, EndOfTimes( ), is called the default constructor, because its argument list is empty. This constructor assigns default values to all data in the object. Thus, in line 14, which uses the default constructor, the data for the ragnarok object is set to the default values for the EndOfTimes class, whichever those may have been. Remember that API’s are designed by authors previously and you can then find them on websites such as the one linked above.

We also see another constructor for the EndOfTimes class, EndOfTimes( int mm, int dd, int yy ), takes three arguments, all of which should evaluate to integer values. The first argument is the value for the month, the second argument is the value for the day, and the third argument is the value for the year. Lines 10 and 12 of instantiate EndOfTimes objects using the second constructor. In line 10, the argument list tells the constructor to give the value 3 to the month, 26 to the day, and 2300 to the year. In line 12, the argument list tells the constructor to give the value 11 to the month, 4 to the day, and 4100000000 to the year (which is out of range).

Note that no data types are given in the argument list, only the initial values for the data. The data types of the arguments are specified in the API so that the client of the class knows what data types the constructor is expecting for its arguments. Lines 12 and 14 also illustrate that you can combine the declaration of the object reference and instantiation of the object in a single statement. When an object is instantiated, the JVM allocates memory to the new object. The object reference is assigned an address that the JVM uses to find that object in memory. The figure below shows one of the three objects instantiated in code above.

Screen Shot 2018-12-20 at 9.42.12 AM


It’s important to understand that an object reference and the object data are different: The object reference represents a memory location. Notice that the object references, maitreya, kaliYuga, and ragnarok, point to the locations of the object data.

 

String Literals and Escape Sequences

In addition to literals for all the primitive data types, Java also supports String literals. String literals are objects of Java’s String class.

A String literal is a sequence of characters enclosed by double quotes. One set of quotes “opens” the String literal and the second set of quotes “closes” the literal. For example, these are all String literals:

Screen Shot 2018-12-11 at 11.01.22 AM

In a previous episode, We used String literals in output statements to label the data We printed. Something like this:

Screen Shot 2018-12-11 at 11.24.37 AM

Screen Shot 2018-12-11 at 11.28.41 AM

The + operator is the String concatenation operator. Among other uses, the concatenation operator allows us to print the values of variables along with String literals. The characters in the String literal are output exactly as typed, whereas the variables are replaced by their current value.

String literals cannot extend over more than one line. If the compiler finds a newline character in the middle of your String literal, it will generate a compiler error. In other words, don’t press the enter key when writing out a String. For example, the following statement is not valid:

Screen Shot 2018-12-11 at 12.03.31 PM.png

My IDE, Eclipse, doesn’t even allow me to place an independent end quote at the end of the statement because it detects a newline character in the middle of the String.

Screen Shot 2018-12-11 at 12.07.32 PM

In fact, Eclipse, automatically fixes this issue. So if you are using this IDE, then you can get away with pressing enter in the middle of a String. But I mention it because I am not familiar with all other IDE’s. Some, like BlueJ, do not automatically resolve this.

If you have a long String to print, break it into several strings and use the concatenation operator. This statement is a correction of the previous invalid statement:

Screen Shot 2018-12-11 at 12.12.49 PM

Another common programming error is omitting the closing quotes. Be sure that all open quotes have matching closing quotes on the same line. Now that we know that quotes open and close String literals, how can we define a literal that includes quotes?

This statement

Screen Shot 2018-12-11 at 12.19.34 PM

is obviously in error.

Apoptosis of two independent quotes is necessary. Or mitosis into two separate String literals concatenated by a “+” operator.

And since String literals can’t extend over two lines, how can we create a String literal that includes a newline character? Java solves these problems by providing a set of escape sequences that can be used to include a special character within String and char literals. The escape sequences \n, \t, \b, \r, and \f are nonprintable characters. The table below lists the Java escape sequences.

Screen Shot 2018-12-11 at 12.29.25 PM

Here, We see how escape sequences can be used in Strings:

Screen Shot 2018-12-11 at 12.39.16 PM

And here is the result:

Screen Shot 2018-12-11 at 12.41.00 PM

 

Assignment Operator, Initial Values, Literals

When you declare a variable, you also assign an initial value to the data. To do that, use the assignment operator (=) with the following syntax:

Screen Shot 2018-12-10 at 8.49.47 AM

This statement is read as “variableName gets initialValue”.

You can also assign more than one variable in the same line if they are of the same dataType, such as here:

Screen Shot 2018-12-10 at 8.53.34 AM.png

Notice that assignment is right to left. The initial value is assigned to the variable.

One way to specify the initial value is by using a literal value. In the following statement, the value 9001 is an int literal value, which is assigned to the variable myPowerLevel.

Screen Shot 2018-12-10 at 9.26.53 AM

Below, I summarize the legal characters in literals for all primitive data types. \n and \t can be used to format output. We’ll discuss these and other escape sequences in the following posts.

Screen Shot 2018-12-10 at 9.33.10 AM

Screen Shot 2018-12-10 at 9.37.18 AM

Screen Shot 2018-12-10 at 9.39.29 AM

Screen Shot 2018-12-10 at 9.41.57 AM

Screen Shot 2018-12-10 at 9.43.47 AM

Screen Shot 2018-12-10 at 9.45.27 AM

Here, I show a complete program illustrating variable declarations, specifying a literal for the initial value of each:

Screen Shot 2018-12-10 at 12.50.18 PM

Line 9 shows a single-line comment. Line 17 declares a double variable named speedOfLight and initializes it with its nm/s value in scientific notation. The speed of light represents the limit on the propagation of causality. The figure below shows the output:

Screen Shot 2018-12-10 at 1.09.27 PM

If you have problems running this, go to run configuration and make sure that you are running the appropriate main class. In this case, the main class is Variables.

Screen Shot 2018-12-10 at 1.13.12 PM

Screen Shot 2018-12-10 at 1.16.05 PM

Another way to specify an initial value for a variable is to assign the variable the value of another variable, using this syntax:

Screen Shot 2018-12-10 at 1.18.18 PM

Two things need to be true for this assignment to work:

• variable1 needs to be declared and assigned a value before this statement appears in the source code.

• variable1 and variable2 need to be compatible data types; in other words, the precision of variable1 must be lower than or equal to that of variable2. For example, in these statements:

Screen Shot 2018-12-10 at 1.26.04 PM

isIntelligent is given an initial value of true. Then isPowerful is assigned the value already given to isIntelligent. Thus, isPowerful is also assigned the initial value true. If isIntelligent  were assigned the initial value false, then isPowerful would also be assigned the initial value false.

And in these statements,

Screen Shot 2018-12-10 at 1.49.24 PM

the initial value of .05 is assigned to dervishTax and then to takyeh. It’s possible to assign a float value to a double, because all values that can be stored as floats are also valid double values. However, these statements are not valid:

Screen Shot 2018-12-11 at 9.43.45 AM

That’s because a float is lower precision than a double. This is the same kind of mistake that is made when People are partitioned into anatomical organs. In the time of Aristotle, People were partitioned into independent hearts. Now, we partition People into independent brains. However, any conversion into a discrete ontological unit in the external physical world, or set thereof, loses what is People.

Even though .05 is a valid float value, the compiler will generate a “possible lossy conversion” error.

Similarly, you can assign a lower-precision integer value to a higher-precision integer variable. There is a table below for your reference that summarizes what can be assigned to what; a variable or literal of any type in the right column can be assigned to a variable of the data type in the left column. Variables need to be declared before they can be used in your program, but be careful to declare each variable only once; that is, specify the data type of the variable only the first time that variable is used in the program. Don’t attempt to declare a variable that has already been declared, as in the following statements:

Screen Shot 2018-12-11 at 9.57.35 AM

This is incorrect because the henryThe has been declared by placing that identifier between double (the type) and a “;”.

You will receive an error message similar to the following:

Duplicate local variable henryThe.

Similarly, once you have declared a variable, you cannot change its data type. Thus, these statements:

Screen Shot 2018-12-11 at 10.04.43 AM

will generate an error message also similar to

Duplicate local variable

So notice that there are two ways of getting the same error message. The IDE I use, Eclipse, certainly doesn’t serve as my free on-call tutor for such basic matters.

So don’t assign a value to a variable after already declaring that variable. And also do not  attempt to change its datatype after it has already been declared.

(Side note: You might wonder why anyone would, even in principle, declare a neighborhood of Kabul as a kind of number – the cluttered, ancient alleyways mired of sand and Afghani street food, the geography, the people, and everything else that makes a neighborhood surely deserves to be represented in word. doubles and ints are for numbers, and strings are for words.

Well it turns out that contrary to what my stupid computer science teacher said, I know that every word can be transmuted to number. That is precisely how machine learning algorithms work. They dissolve Van Gogh to number, NSFW to number, Cat to number, and, eventually, ever-so eventually, You to number. By placing a discriminator for the sea of digits to aim at, a GAN can be trained to create Van Gogh from sheer randomness.

Hence, I don’t cringe at using a neighborhood name for a double or int, instead of using an example with things we more conventionally think of as number, such as emeraldsInPocket.)

Screen Shot 2018-12-11 at 10.40.38 AM

What you find in the right can be assigned to what is on the left without lossy conversion error.

 

 

 

 

 

 

 

 

 

Declaring Variables

A variable consists of a dual nature. It has a data type and a name.

Every variable must be given a name and a data type before it can be used. This is called declaring a variable. The syntax for declaring a variable is:

Screen Shot 2018-12-08 at 11.58.39 PM

or

Screen Shot 2018-12-09 at 4.00.02 PM

Note that a comma follows each identifier in the list except the last identifier, which is followed by a semicolon. By convention, the identifiers for variable names start with a lowercase letter. If the variable name consists of more than one word, then each word after the first should begin with a capital letter.

For example, these identifiers are conventional Java variable names: jewel3, specialRelativity, deathToNote, redInNovember, and xAxis.

Underscores conventionally are not used in variable names; they are reserved for the identifiers of constants, as we shall discuss in a later post.

Similarly, do not use dollar signs to begin variable names. The dollar sign is reserved for the first letter of programmatically generated variable names—that is, variable names generated by software, not people. Like with life in general, although arbitrariness may sound a disagreeable thing now, the value of following these conventions will become clearer as you gain more experience in Java and your programs become more complex.

 

Data Types, Variables, and Constants

In the previous blog post where we calculated the area of the last of the nine circles of hell, we used as data the value of PI and the radius, and found how large was Treachery. For each of these values, we assigned a name.

We also used the Java keyword double, which defines the data type of the data. The keyword double means that the value will be a floating-point number.

Java allows you to refer to the data in a program by defining variables, which are named locations in memory where you can store values. A variable can store one data value at a time, but that value might change as the program executes, and it might change from one execution of the program to the next. The real advantage of using variables is that you can name a variable, assign it a value, and subsequently refer to the name of the variable in an expression rather than hard-coding the specific value.

When we use a named variable, we need to tell the compiler which kind of data we will store in the variable. We do this by giving a data type for each variable. Java supports eight primitive data types: byte, short, int, long, float, double, char, and boolean. They are called primitive data types because they are part of the core Java language. The data type you specify for a variable tells the compiler how much memory to allocate and the format in which to store the data.

For example, if you specify that a data item is an int, then the compiler will allocate four bytes of memory for it and store its value as a 32-bit signed binary number. If, however, you specify that a data item is a double (a double-precision floating-point number), then the compiler will allocate 8 bytes of memory and store its value as an IEEE 754 floating-point number. Once you declare a data type for a data item, the compiler will monitor your use of that data item. If you attempt to perform operations that are not allowed for that type or are not compatible with that type, the compiler will generate an error.

Because the Java compiler monitors the operations on each data item, Java is called a strongly typed language. Take care in selecting identifiers for your programs. The identifiers should be meaningful and should reflect the data that will be stored in a variable, the concept encapsulated by a class, or the function of a method.

For example, the identifier age clearly indicates that the variable will hold an age. When you select meaningful variable names, the logic of your program is more easily understood, and you are less likely to introduce errors. Sometimes, it may be necessary to create a long identifier in order to clearly indicate its use, for example, numberOfPeopleSignedUpForCryonics. Although the length of identifiers is essentially unlimited, avoid creating extremely long identifiers because the longer the identifier, the more likely you are to make typos when entering the identifier into your program and the more it takes to type it, swallowing precious time. Finally, although it is legal to use identifiers, such as TRUE, which differ from Java keywords only in case, it isn’t a good idea because they easily can be confused with Java keywords, making the program logic less clear.

Writing the First Java Application

Here, you become initiated. Here, you create your first Java program. In the beginning was the static void, but here, with your own fingers, you create. This program prints the message, “Donate to SENS!” on the screen. Start by launching your IDE and open a new editor window. This is where you will write the code for the program. Before we type any code, however, let’s name the document. We do this by saving the document as IAmTheSavior.java. Be sure to capitalize the I, and the A, and the T, and the S, and keep the other letters lowercase. Java is case-sensitive, so Java considers iamthesavior.java or even Iamthesavior.java to be a different name.

Screen Shot 2018-12-07 at 7.02.36 PM

At this point, We ask that you type the program as you see it here. You are my mirror, and I create you in my image.

I’ll only give away a few secrets about the program now; additional details will unravel and become clear unto you in the following days.

Line numbers are not part of the program but are displayed to allow easy reference to a particular line in the code.

The first two lines, which start with two forward slashes, are comments. They will not be compiled or executed; they are simply information for the programmer and are used to leave notes that increase the readability of the program.

Line 4 defines the class name as IAmTheSavior. Notice that the class name must be spelled exactly the same way—including capitalization—as the file name, IAmTheSavior.java.

The curly braces in lines 5 and 12 mark the beginning and the end of the IAmTheSavior class, and the curly braces in lines 7 and 11 mark the beginning and the end of main.

Every Java application must define a class and a main method. Execution of a Java application always begins with the code inside main. So when this application begins, it will execute line 8, which writes the message “Donate to SENS!” to the system console.

Next, it executes line 10, System.exit( 0 ), which exits the program. Including this line is optional; if you omit this line, the application will exit normally. So it is just showing off my capacity to waste time or do things quickly. Never do unnecessary things.

As you type the program, notice that your IDE automatically colors your text to help you distinguish comments.

There are:

String literals: (“Donate to SENS!”),

Java class names: (String, System),

and keywords: (public, class, static), which are reserved for specific uses in Java.

Curly braces, brackets, and parentheses, which have syntactical meaning in Java, are sometimes displayed in color as well. Your IDE may use different colors instead of black as I have on Eclipse. When you have completed typing the code revealed to you in the image, compile it by going to wherever you see Run. If everything is typed correctly, the compiler will create an IAmTheSavior.class file, which contains the byte codes for the program. If you received any compiler errors, check that you have entered the code exactly as I have commanded. I will give you tips on finding and fixing the errors in the next section.

If you got a clean compile with no errors, you are worthy of this path! If not, then stop now and return from whence you came, for thee are destined to be but a kitchen-knave.

You’re ready to execute the application. This will invoke the JVM and pass it the IAmTheSavior.class file created by the compiler. If God’s in his heaven and all is right in the world, you will see the message, Donate to SENS!, displayed on the Java console, which is the text window that opens automatically.

This is the correct output of the program:

Screen Shot 2018-12-07 at 7.36.54 PM

If the compiler found syntax errors in the code, these are called compiler errors, not because the compiler caused them, but because the compiler found them. When the compiler detects errors in the code, it writes diagnostic information about the errors. For example, try typing println with a capital P (as Println), and recompiling.

The compiler displays the following message:

Screen Shot 2018-12-07 at 7.42.54 PM

Before you compile wrongly, you are allowed to know about your error in the source code, and where the error occurred:

Screen Shot 2018-12-07 at 7.45.46 PM

 

In this case, the error occurred on line 8. The red dashed underlining points to Println as being the cause of the error. The symbol and location information in the third and fourth lines indicate that the Println method is unknown. Remember that Java is case-sensitive, so println and Println are considered to be different. As you gain experience with Java, these error messages will become more meaningful to you.

With the Eclipse IDE, clicking on the red rectangle on the right transfers you to the source of the error on that line, so you can correct the error:

Screen Shot 2018-12-07 at 7.53.33 PM

 

Many times, the compiler will find more than one error in the source code. When that happens, DON’T PANIC! Often, a simple problem, such as a missing semicolon or curly brace, can cause multiple compiler errors.

For example, after correcting the preceding error, try deleting the left curly brace in line 7, then recompiling.

Screen Shot 2018-12-08 at 7.43.05 AM

The compiler reports this error:

Screen Shot 2018-12-07 at 7.58.44 PM

As you can see, the compiler message reports the problem exactly. If it does not, then looking at the surrounding lines will often help you find the error. Depending on your IDE, you might see another message than what is shown here because some IDEs don’t attempt to interpret the error messages from the compiler. Eclipse does, and this allows you to be provided with more relevant information on the errors.

It is best to fix the errors using an IDE, if you wrote the code into a text editor and had to gamble a compile each time – fixing one problem at a time – this would cause you to waste your existence in some sense.

When all the compiler errors are corrected, you’re ready to execute the program. It is possible to get be told you are clean by the IDE, but yet still get an error when attempting to run the program. To demonstrate this, try eliminating the brackets in line 6 after the word String:

Screen Shot 2018-12-08 at 7.58.39 AM

No errors are reported. But when you try to run the program, instead of Donate to SENS!, the following error message is displayed:

Screen Shot 2018-12-08 at 8.00.13 AM

This means that the main method header (line 6) was not typed correctly. Thus, we’ve seen that two types of errors can occur while you are developing a Java program: compiler errors, which are usually caused by language syntax errors or misspellings, and run-time errors, which are often caused by problems using the prewritten classes. Run-time errors can also be caused by exceptions that the JVM detects as it is running, such as an attempt to divide by zero.

Because one syntax error can cause multiple compiler errors, correct only the obvious errors and recompile after each correction.

Once your program compiles cleanly and executes without run-time errors, you may be tempted to conclude that your task is over. Far from it—you must also verify the results, or output, of the program.

Screen Shot 2018-12-08 at 8.18.35 AM

In the sample program, it’s difficult to get incorrect results—other than misspelling the message or omitting the spaces between the words. But any nontrivial program should be tested thoroughly before declaring it production-ready. To test a program, use your intuition to consider the relevant possible inputs and the corresponding correct outputs that result. It isn’t feasible to test every possible input, so programmers usually test boundary conditions, which are the values that sit on the boundaries of producing different output for a program.

Interestingly, we exist in a multiverse if we are empiricists with regard to the probability amplitude of the universal wavefunction. We then get a handle on probability amplitude with a complex conjugate:

i ± 1

The reason we represent reality with a complex conjugate is because all variables are conjugated – the more you know about momentum, the less you know about position. However, there is no little electron zipping around, or occipital lobes trying to catch it, it’s conjugated variables all the way up and all the way down.

Staring at the probability amplitude represented in complex conjugates suggests that infinity contains equal amounts of good and evil – undifferentiated chaos.

However, experiment reveals that some things are more likely than others. This causes us to take the squared modulus of the complex conjugate, hence invoking rough bounds that chain infinity and guide our being:

|i ± 1|²

This is the probability density that says, “look here, not there.”

Hydrogen_Density_Plots.png

Say you have a problem, or perhaps a curiosity – you want to test the code that determines whether an integer is negative or nonnegative. In order to find out the answer, you must submit the program offerings of both −1 and 0, so that it may feed on them. These chosen numbers exist at the very edges of negative and nonnegative integers, and hence form their boundaries. In other words, the unbridgeable fault-line between negative and nonnegative integers is between −1 and 0.

When a program does not produce the correct output, we say the program contains logic errors. By testing your program thoroughly, you can discover and correct all logic errors. The grey table above shows types of program errors and their usual causes. We’ll talk more about testing techniques here on Vitrify Her.