Memorandum

To: Dr. Newmark

From: Troy Wiseman
Date: date
Re: Document in field

The purpose of this memorandum is to display a rewritten a passage from a scholarly article that is
much more understandable to the average population.
Overview:
I have rewritten a Computer Science passage Standard Fixpoint Iteration for Java Bytecode
Verification by Zhenyu Qian taken from the journal ACM Transactions on Programming Languages and
Systems. Also included in this memorandum is the original passage as it appears in the article.

Revised Passage:
The Java programming language, referred to as JVM or Java Virtual Machine is stack based, meaning
commands are executed from top to bottom. When programs are written using this language the Java
instructions are converted into JVM instructions that can then be understood by the computer. These
JVM instructions consist of commands that can be run by the computer. When a Java program is run the
variables set in the program stack are started and when the program is ended the variables are
terminated.
Within this article both stacks and variables will be referred to as memory locations. Memory locations
are bits of data that refer to either reference locations or basic data points such as the number one or
the letter G. The memory locations tell the program where to look for information in the stack heap.
Java programs are able to be taken and run directly from a workplace or home network, doing this
however does not guarantee that the program will not cause problems, either in the form of bugs or
malicious code. Sun microsystems, the developers of the Java computer language require that the
program passes what is known as bytecode verification. Bytecode verification ensures that the
programs code is well typed. If the programmer is able to write Java variables that only use and store
data in a specific location and the data is of the proper basic structure, then the program is well written.
Original passage:
The Java Virtual Machine (JVM) is a stack-based abstract computing machine. Java methods are usually
compiled into JVM methods, which consist of JVM instructions. During execution, an (operand) stack
and a set of registers called local variables are created on each method invocation and destroyed when
the method execution completes.

In this paper, stack entries and local variables are uniformly called memory locations. They hold data
that are either object references or values of primitive types. Object references point to objects stored
in the heap. We consider only object references but no objects themselves, nor the heap in this paper.
Since a JVM method may be dynamically loaded from the network, there is no guarantee that it contains
no bugs or has no hostile intentions to break the host system. Sun's JVM Specification [Lindholm and
Yellin 1996] (SJVMS) requires, that prior to execution, bytecode verification must be performed to
prove, among other things, that each newly loaded JVM method is (statically) well-typed. Informally, if
one can statically assign types to all memory locations at all program points(1) in a JVM method such
that instructions only use and store data from and into memory locations with correct assigned types,
then the method is well-typed and the assignment of types is a legal assignment for the method.
Discussion:
My revision aims to be a nearly complete rewrite of the original article in much more general terms.
Most of the technical terms such as method or object have been removed and changed to reflect
their basic meaning. The only acronym in the article JVM has been defined and its usage has been kept
to a minimum. Certain sections of the article have been lengthened while others have been shortened. I
do believe my revision is much clearer and much more easily understood than both the previous
revision and the original article.