ch1.htm

JAVA Developing Professional JavaApplets

Since it is written in software, however, it is portable. All
that's needed to take Java code compiled on one platform and run
it on another is to provide a Java interpreter and runtime environment.
The runtime system is written in an easily portable fashion. Once
you have this system, everything becomes easy. You don't even
have to port the Java compiler-it is written in Java!
<P>
Another advantage of the Java interpreter is that it improves
software development by eliminating the link phase of the development
process. You can go straight from compiling your code to executing
it. Linking actually occurs at runtime through mechanisms discussed
in the section &quot;Java as a Secure Environment.&quot;
<P>
A couple of higher-level features also improve Java's portability.
The Abstract Window Toolkit (or AWT) is constructed to be a visual
interface that is portable across platforms. This way your applets
will look good regardless of the underlying interface. They will
have the proper &quot;look and feel&quot; on Microsoft Windows,
the Macintosh, or X-Windows. Although not a portability issue
in the strict sense, Java stores characters by using the 16-bit
Unicode format as opposed to the 8-bit ASCII standard. Unicode
is used if you need to support international character sets. Since
the Internet is an international network, this consideration is
important.
<H3><A NAME="JavaasHighPerformance">Java as High Performance</A>
</H3>
<P>
One of the reasons why Java's portable solution is such a coup
is that interpreted platforms have generally been very slow. Often
their performance is so poor that systems based on these interpreters
have been unusable. Java's bytecode system, however, provides
a &quot;lean and mean&quot; interpreted solution. It isn't based
on multimegabyte executable &quot;image&quot; files. Rather, the
runtime system works with small binary <I>class files</I> compiled
to Java virtual machine code. These files typically have a size
of only a few kilobytes.
<P>
However, Java offers more than just the byte-code system to get
high performance. Since the byte-code system is at a low level,
it can be easily converted at runtime to the native platform.
Just-in-time Java compilers will be out in the near future to
allow this. Another performance enhancement is a by-product of
another Java feature. When a class is brought into memory at runtime,
it runs through a verification process as part of the Java security
mechanism (discussed in the section &quot;Java as a Secure Environment&quot;).
This process not only guarantees that the code you are loading
is secure, but the end result is code that requires less runtime
checks. These checks, which otherwise would hurt performance,
now don't need to be executed. For example, the runtime system
does not have to check for stack overflows on verified code.
<P>
One of the key features that Java offers to improve performance
is <I>multithreading.</I> Most interactive applications are characterized
by large periods of time during which the user pauses between
actions to decide what to do next. In traditional single-threaded
environments, the application may sit idle during such periods.
In multithreaded environments, however, the application can perform
other tasks during these types of delays or at any other time.
This is critical for network applications, which can take long
periods of time to load files. Wouldn't it be more efficient if
you could read the current page of text while the next page is
being downloaded? Multithreading also greatly improves the usability
of multimedia applications. For example, you need to be able to
interact with your system while a sound or a movie is playing.
Multithreading is useful for even more down-to-earth things, such
as running a background thread that spell checks your document
as you are typing in words.
<P>
You can use Java's easy-to-use multithreading environment to perform
all kinds of optimizations to your program. In fact, the designers
of Java have taken great pains to make sure it's easy to write
multithreaded programs. Historically, writing multithreaded applications
has been quite difficult-a key reason they have appeared infrequently.
Furthermore, Java uses threads to improve its own performance.
The garbage collector that takes care of your memory management
concerns runs in the background as a low-priority thread. So even
when your program is doing nothing, the garbage collector could
be busy optimizing memory!
<P>
There are some other interesting things Java does to guarantee
good performance. As stated earlier, Java is &quot;objects all
the way down.&quot; In some object-oriented systems, primitives
such as integers and floating point numbers are implemented only
as objects. So to perform an operation such as adding two numbers,
you actually have to call an object method. If you are doing some
serious number crunching, this will absolutely kill your performance.
Java has an intermediate solution to resolve the dilemma between
having good performance and being a pure object-oriented system.
It implements &quot;type wrappers&quot; to take primitives, such
as numbers, and make them appear as objects. This way, methods-such
as converting numbers to strings-can be performed by using the
object-oriented method style. However, if you need to work with
raw data types, you can use the primitive formats to produce such
things as CPU-intensive images like fractals. Java can even be
used to create the computation-hungry Mandelbrot set. It's rather
remarkable that Java can do this; if you don't believe it can,
then see <A HREF="ch14.htm" >Chapter 14</A>, &quot;Advanced Image
Processing.&quot;
<P>
If you really need that final push to your performance, Java can
link to executable code written in a low-level native language
such as C. Java code that does this is said to use <I>native methods</I>.
This technique can also be used to implement platform-specific
features. However, using native methods is not without its drawbacks;
it will probably compromise the portability of your code. Fortunately,
Java performance is generally good enough that you don't need
to bring in native methods very often.
<P>
Finally, it is important to remember that the Java community is
constantly working on techniques to improve performance but not
compromise all the other features of Java, such as portability.
The just-in-time compilers that will be out later this year are
among the most impressive of such optimizations.
<H3><A NAME="JavaintheWorldofDistributedComputin">Java in the World
of Distributed Computing</A></H3>
<P>
Much of what has been discussed so far makes Java well suited
for network computing. In particular, the lightweight nature of
the binary class files makes it possible to download Java code
without serious performance hits. Multithreading is also critical
for latency-laden network operations; your applet can download
code and resources in the background while the end user is deciding
the next action to take. Portability frees you from knowing how
your applet will run and what it will look like on your potential
client's unknown platform.
<P>
Another feature of Java that makes it excellent for distributed
computing is that it's <I>dynamic</I>. Since there is no linking
phase after compilation, the resolution of references is put off
until runtime. Java also does not calculate the layout of objects
in memory until they are used at runtime. Consequently, if you
add a new method to one class, you don't have to recompile another
class that uses the class but not the method. In C++, you are
constantly having to recompile multiple classes because one is
&quot;dependent&quot; on the other-this is known as the &quot;fragile
superclass problem.&quot; In its typical efficient manner, Java
solves the superclass problem while taking care of other issues.
Since the Java dynamic system removes difficulties caused by unnecessary
dependencies, it's easy to download a special subclass to handle
a specific situation without worrying about &quot;linking&quot;
problems.
<P>
The Java development package also gives you a variety of good
communication constructs. The message-passing mechanism of its
objects can be used to let two different applets communicate;
this is known as &quot;inter-applet communication.&quot; Sockets,
pipes, and thread synchronization constructs also provide other
easy-to-use communication mechanisms. In short, Java provides
all the basics for creating distributed systems.
<H3><A NAME="JavaasaSecureEnvironment">Java as a Secure Environment</A>
</H3>
<P>
Although distributed systems are extremely powerful, they open
the door to a range of security problems, which are particularly
serious on a vast open network like the Internet. For normal data
transmission, you have to be concerned with someone eavesdropping
on your information as it passes through the network. If you have
a server on the Internet, you have to worry about someone breaking
in and wreaking havoc on your internal network. And if you're
downloading applications from the net, you have to worry about
it causing damage to your host system.
<P>
The kind of damage a poorly written application could inflict
on your host spans a range of extremes. On one hand, a poorly
written application can misuse the resources of your system, taking
resources you might need elsewhere. For example, a C program that
mismanages memory can simply take memory that another one of your
applications needs. If the program is really bad, it can cause
your system to lock up. Fortunately, it's usually easy to recover
from such problems. However, the other end of the extreme is not
quite so innocent. A malicious program can attack some of the
most critical resources of your computer, such as your hard disk,
causing damage less easily fixed. If the program is a virus, it
can be even more pernicious. It can lie in wait for weeks or even
months, then one day pounce on your computer and connecting network,
causing hours or even days of lost work time. If this attack came
from an application that you ran from the World Wide Web, you
would probably be reluctant to use the Web again. Consequently,
bad Web programs not only threaten your system, but the viability
of the Web as a whole.
<P>
The designers of Java know just how important security is. For
this reason, they built a multi-layered security system whose
presence is felt throughout Java. This security model consists
of four main layers:
<UL>
<LI><FONT COLOR=#000000>The </FONT><B>language</B> itself is designed
to be safe. A strict <B>compiler</B> prevents generating bytecodes
that don't completely follow extensive safety rules.
<LI><FONT COLOR=#000000>A runtime </FONT><B>bytecode verifier</B>
that inspects class bytecodes as they are loaded into the system.
Since code loaded at runtime has already passed through the compilation
stage, Java cannot know that it hasn't been produced by a malicious
or weak compiler that does not follow all the language's safety
rules.
<LI><FONT COLOR=#000000>Once code has been verified, it needs
to be loaded into a runtime namespace. This is performed by a
module called the </FONT><B>Class</B> <B>Loader</B>, represented
by a like-named class. Java has a different namespace depending
on whether the loaded class came from a local file system or across
a network. These separate namespaces prevent a class from passing
itself off as a new low-level class. Therefore, it can't do such
things as replacing the existing Security Manager (discussed briefly
in the next bulleted item).
<LI><FONT COLOR=#000000>The final layer performs checks on the
code as it's being executed. This layer makes sure the code does
not violate any security restrictions defined for the current
environment; it's generally represented by a module called the
</FONT><B>Security Manager</B>, which corresponds to a Java class
of a similar name. An applet that can delete a file on your computer
is an example of something that falls under the auspices of the
Security Manager. The workings of Security Managers can vary on
different environments. Extremely conservative Java-enabled browsers,
such as Netscape Navigator, actually prevent applets from reading
or writing to your local file system altogether. The HotJava browser,
on the other hand, can be configured to authorize file operations
more flexibly.
</UL>
<P>
Figure 1.1 gives an overview of the lifetime of Java code as it
travels through the layers of security. Those modules related
to security are set off in boldface.
<P>
Since security is such a critical part of Java, it is worth taking
a moment to look at it in greater detail. In doing so, you will
get some greater insight into the inner workings of Java.
<P>
<A HREF="f1-1.gif" >Figure 1.1 : <I>The Java life</I>-cycle in relationship to its security layers.</A>
<H4>First Security Layer: The Language and Compiler</H4>
<P>
You have already seen a couple of reasons why Java is a secure
language. A key ingredient here is removing pointers from Java.
Without pointers, a bad or malicious program cannot invade the
memory space of other applications. This removes a major source
of attack for viruses. For example, a threatening program cannot
use Java as a launching pad to directly attack your operating
system kernel. Furthermore, the absence of pointers makes the
Java applet itself more secure and reliable. An applet won't crash
because of a &quot;dangling pointer,&quot; as is often the case
in C and C++.
<P>
Another security feature of the language is its class access mechanism.
Classes can control the kinds of access other classes have to
their methods and variables. There are four access modifiers,
ranging from <TT>public</TT>, which
indicates availability to all classes, to <TT>private</TT>,
which makes a method or variable accessible only from within the
class where it's defined. These modifiers can make your class
more secure by denying other classes access to critical behavior.
For example, if you have a class that manages critical data in
a private method, another class cannot invoke that method to change
the data. Access modifiers will be discussed in more detail in
the next section.
<P>
The compiler uses very strict checking to ensure adherence to
these and other Java language constructs. Java is a strongly typed
language, so runtime bugs aren't introduced because of freely
casting one type of object to another. A language like C is notorious
for its loose casting mechanism. A pointer to a structure can
be fairly easily cast into a long integer, and vice versa. When
such casting is done incorrectly, pernicious and difficult-to-find
bugs can be introduced, but this kind of casting is eliminated
in Java. All casts must be explicit, and those that don't follow
the semantics of the language are disallowed. Because the compiler