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.


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.





Calling Methods

Once an object is instantiated, as in “Let there be light,” we can use the object by calling its methods. As I mentioned in the previous post, the authors of classes publish their API so that their clients know what methods are available and how to call those methods. The figure below illustrates how calling a class method alters the flow of control in your program. When this program starts running, the JVM executes instruction 1, then instruction 2, then it encounters a method call.

Screen Shot 2018-12-20 at 10.50.16 AM

At that point, the JVM transfers control to the method and starts executing instructions in the method. When the method finishes executing, the JVM transfers control back to the program immediately after the point the method was called and continues executing instructions in the program.

A class API consists of the class method names, their return values, and their argument lists.

Screen Shot 2018-12-20 at 12.51.17 PM

The argument list for a method indicates the order and number of arguments to send to the method, along with the data type of each argument. Each item in the argument list consists of a data type and a name. The arguments can be literals, constants, variables, or any expression that evaluates to the data type specified in the API of the method.

For example, the API in the table below shows that the setMonth method takes one argument, which must evaluate to an integer value. A method may or may not return a value, as indicated by a data type, class type, or the keyword void in front of the method name. If the method returns a value, then the data type or class type of its return value will precede the method’s name.

For instance, in the previous post, a getDay method would return an integer value. The call to a value-returning method will be used in an expression. When the method finishes executing, its return value will replace the method call in the expression. If the keyword void precedes the method name, the method does not return a value. Because methods with a void return type have no value, they cannot be used in an expression; instead, a method call to a method with a void return type is a complete statement. In the previous post’s scheme, a setYear method would be a void method.

Another keyword you will see preceding the method call in an API is public. This keyword means that any client of the class can call this method. If the keyword private precedes the method name, only other methods of that class can call that method. Although I will not formally include the public keyword in the API, all the methods I plan to discuss in the following posts are public.

To call a method for an object of a class, we use dot notation, as follows:

Screen Shot 2018-12-20 at 10.56.42 AM

The object reference is followed immediately by a dot (a period), which is followed immediately by the method name. (Later, when we call static methods, we will substitute the class name for the object reference.) The arguments for the method are enclosed in parentheses. Let’s look again at the methods of the EndOfTimes class. The first three methods in the hypothetical EndOfTimes class API take an empty argument list and return an int; thus, those methods have a return value of type int. You can call these methods in any expression in your program where you could use an int.

The value of the first method, getMonth( ), is the value of the month in the object. Similarly, the value of getDay( ) is the value of the day in the object, and the value of getYear( ) is the value of the year. These “get” methods are formally called accessor methods; they enable clients to access the value of the instance variables of an object.

The next three methods in the EndOfTimes class API take one argument of type int and do not return a value, which is indicated by the keyword void. These methods are called in standalone statements. The first method, setMonth( int mm ), changes the value of the month in the object to the value of the method’s argument, mm. Similarly, setDay( int dd ) changes the value of the day in the object, and setYear( int yy ) changes the value of the year in the object to the value of the method’s argument. These “set” methods are formally called mutator methods; they enable a client to change the value of the instance variables of an object.

The code below illustrates how to use some of the methods of the EndOfTimes class.

Screen Shot 2018-12-20 at 1.41.35 PM

EndOfTimes is underlined red because this API class doesn’t exist and is therefore merely hypothetical. The year of Kali Yuga is too far so it is also not useful to place an end to time so far away.

Line 10 calls the getMonth method for the maitreya object. When line 10 is executed, control transfers to the getMonth method. When the getMonth method finishes executing, the value it returns (7) replaces the method call in the statement. The statement then effectively becomes:

Screen Shot 2018-12-20 at 1.15.04 PM.png

In lines 16–17, we print the value of the day in the kaliYuga object. Again, control transfers to the getDay method, then its return value (30) replaces the method call. So the statement effectively becomes:

Screen Shot 2018-12-20 at 2.00.29 PM

Line 16 calls the setDay method, which is used to change the value of the day for an object. The setDay method takes one int argument and has a void return value. Line 17 is a complete statement, because the method call to a method with a void return value is a complete statement. The method changes the value of the day in the kaliYuga object. Then, on line 19, we instantiate another object, christ, with a month, day, and year of 11, 12, 1817, which I demonstrate by printing the values returned by calls to the getMonth, getDay, and getYear methods. Baha u’llah was born on that day month and year, and claimed to be the return of Jesus. (This is not, however, the beginning of the new calendar for the Baha’i.)

On line 25, we call the nextDay method, which has a void return value, and increments the date to the next day, and then we print the new values of the christ object.


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 file in the same folder as

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.


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 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 or even 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,

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.”


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.




Developing a Java Application

Writing a Java application consists of several steps: writing the code, compiling the code, and executing the application. Java source code is stored in a text file with the extension .java. Compiling the code creates one or more .class files, which contain processor-independent byte codes.

Screen Shot 2018-12-07 at 5.29.57 PMThe Java Virtual Machine (JVM) then translates the byte codes into machine-level instructions for the processor on which the Java application is running.

Thus, if a Java application is running on an Intel Core i9-9900K processor, the JVM translates the byte codes into the i9-9900K’s instruction set.

You can get a Java SE Development Toolkit (JDK) on the Oracle website free of charge. The JDK allows you to build applications, applets, and components using the Java programming language. In addition, the JDK contains a broad range of prewritten Java classes that programmers can use in their Java applications. If you are downloading and installing Java yourself, be sure to choose your appropriate operating system when you download, and follow the directions on the Oracle website, including the directions for setting the path for javac, the Java compiler. You need to set the path correctly so that you can run the Java compiler from any directory on your computer. To develop an application using the JDK, write the source code using any text editor, such as Notepad on Windows, TextEdit on Macs, or the vi editor on a Unix operating system. To compile the code, invoke the compiler from the command line:

Screen Shot 2018-12-07 at 5.13.43 PM

where is the name of the source file. So remember that when you save the source code you write into the text editor, this must end in .java.

If your program, written in the file, compiles correctly, a new file, ClassName.class, will be created in your current directory. To run the application, you invoke the JVM from the command line:

Screen Shot 2018-12-07 at 5.40.21 PM

Okay, now never do that again.

Typically, programmers use an Integrated Development Environment (IDE) instead of a text editor and the command line to develop applications. An IDE consists of a program editor, a compiler, and a run-time environment, integrated via a Graphical User Interface. One of the many advantages to using an IDE is that errors in the Java code that are found by the compiler or the JVM can be linked directly to the program editor at the line in the source file that caused the error. Everything looks nicer too – the Graphical User Interface enables you to have the editor and compiler in the same place, and therefore execute the program without launching separate applications:

Screen Shot 2018-12-07 at 5.56.33 PM


Some of the many available IDEs include Eclipse ; intelliJ IDEA; BlueJ. Use Google for more.

Pick one at random.

The Java Language

There are applications that are called embedded applications because they are meant to stay inside the device. These embedded applications include user interfaces for example. It is also useful to store them in non-volatile memory such as ROM.

You are an embedded application yourself. Special relativity implies relativity of simultaneity, which in turn implies eternity. Everything is stored in the ultimate non-volatile memory – the fabric of spacetime itself.

On what we call May 23, 1995, Sun Microsystems introduced Java, originally named Oak, as a free, object-oriented language targeted at embedded applications for consumer devices.

A Java Virtual Machine was incorporated immediately into the Netscape Navigator Internet browser, and as the Internet exploded in rapid combustion, small Java programs, known as applets, began to blossom on webpages in increasing numbers.

Java syntax is basically identical (with some minor exceptions) to that of C++. Remember that high redundancy of genotype in a highly connected network is what allows evolution to find the next best step up in phenotype, and soon programmers in one Earth constrained by the probability density given by the Born Rule started to realize the benefits of using Java. Those benefits include

• syntax mirroring that of C++, except that Java eliminates some of C++’s more complex features

object orientation

• Internet-related features, such as applets, which are run by the browser, and servlets, which are run by the web server (Remember that you don’t just run your website from home, there are giant facilities with web server’s whose only purpose is to store websites until someone wants to visit them – ignoring of course, their ultimate purpose which is to increase synthesis in Me. However, this ulterior purpose is not readily visible because the “constituents” that make up your experience are “bound” in the absence of time.)

• an extensive library of classes that can be reused readily, including Swing classes for providing a Graphical User Interface and Java Database Connectivity (JDBC) for communicating with a database

portability among every platform that supports a Java Virtual Machine

built-in networking

• open source availability of the Java Development Kit

As was read in a previous post, a Java program is first compiled into processor-independent byte codes, then the byte codes are interpreted at run time by the Java Virtual Machine (JVM). As its name implies, the JVM simulates a virtual processor with its own instruction set, registers, and instruction pointer. Thus, to run a Java program, you only need a JVM. JVMs are available on every major computing platform.

Because Java programs are interpreted at run time, they typically run more slowly than their C++ counterparts. However, many platforms provide Java compilers that convert source code directly to machine code. This results is greater execution speed, but with an accompanying loss of portability. Just-in-Time (JIT) compilers are also available. These JITs compile code at run time so that subsequent execution of the same code runs much faster.

Java programs can be written as applets, servlets, or applications.

Java applets were small programs designed to add interactivity to a webpage. Applets were launched by an Internet browser; they could not run standalone. As the user requested a webpage that used an applet, the applet was downloaded to the user’s computer and run by the JVM in the browser. Due to browser incompatibilities, limitations imposed by security features, and slow download times, however, applets have fallen out of favor.

Java servlets are invoked by the web server and run on the server, without being downloaded to the client (your own computer). Typically, servlets dynamically generate web content by reading and writing to a database using JDBC (Java Database Connectivity).

Java applications run standalone on a client computer. On this site, we will mainly write Java applications.

Oracle Corporation, which ate Sun Microsystems in January 2010, provides a valuable Java website, which has information on using the prewritten classes, a tutorial on Java, and many more resources for the Java programmer.