The Java Buzzwords

No discussion of the genesis of Java is complete without a look at the Java buzzwords.
Although the fundamental forces that necessitated the invention of Java are portability
and security, other factors also played an important role in molding the final form of
the language. The key considerations were summed up by the Java team in the
following list of buzzwords:
❦ Simple
❦ Secure
❦ Portable
❦ Object-oriented
❦ Robust
❦ Multithreaded
❦ Architecture-neutral
❦ Interpreted
❦ High performance
❦ Distributed
❦ Dynamic
Two of these buzzwords have already been discussed: secure and portable. Let’s
examine what each of the others implies.

THE
JAVA
L Security
As you are likely aware, every time that you download a “normal” program, you
are risking a viral infection. Prior to Java, most users did not download executable
programs frequently, and those who did scanned them for viruses prior to execution.
Even so, most users still worried about the possibility of infecting their systems with
a virus. In addition to viruses, another type of malicious program exists that must be
guarded against. This type of program can gather private information, such as credit
card numbers, bank account balances, and passwords, by searching the contents of
your computer’s local file system. Java answers both of these concerns by providing
a “firewall” between a networked application and your computer.
When you use a Java-compatible Web browser, you can safely download Java
applets without fear of viral infection or malicious intent. Java achieves this protection
by confining a Java program to the Java execution environment and not allowing it
access to other parts of the computer. (You will see how this is accomplished shortly.)
The ability to download applets with confidence that no harm will be done and that
no security will be breached is considered by many to be the single most important
aspect of Java.
Portability
As discussed earlier, many types of computers and operating systems are in use
throughout the world—and many are connected to the Internet. For programs to
be dynamically downloaded to all the various types of platforms connected to the
Internet, some means of generating portable executable code is needed. As you will
soon see, the same mechanism that helps ensure security also helps create portability.
Indeed, Java’s solution to these two problems is both elegant and efficient.
Simple
Java was designed to be easy for the professional programmer to learn and use
effectively. Assuming that you have some programming experience, you will not find
Java hard to master. If you already understand the basic concepts of object-oriented
programming, learning Java will be even easier. Best of all, if you are an experienced
C++ programmer, moving to Java will require very little effort. Because Java inherits
the C/C++ syntax and many of the object-oriented features of C++, most programmers
have little trouble learning Java. Also, some of the more confusing concepts from C++
are either left out of Java or implemented in a cleaner, more approachable manner.
Beyond its similarities with C/C++, Java has another attribute that makes it easy
to learn: it makes an effort not to have surprising features. In Java, there are a small
number of clearly defined ways to accomplish a given task.
Object-Oriented
Although influenced by its predecessors, Java was not designed to be source-code
compatible with any other language. This allowed the Java team the freedom to design
with a blank slate. One outcome of this was a clean, usable, pragmatic approach to
objects. Borrowing liberally from many seminal object-software environments of the
last few decades, Java manages to strike a balance between the purist’s “everything is
an object” paradigm and the pragmatist’s “stay out of my way” model. The object
model in Java is simple and easy to extend, while simple types, such as integers, are
kept as high-performance nonobjects.
Robust
The multiplatformed environment of the Web places extraordinary demands on a
program, because the program must execute reliably in a variety of systems. Thus, the
ability to create robust programs was given a high priority in the design of Java. To
gain reliability, Java restricts you in a few key areas, to force you to find your mistakes
early in program development. At the same time, Java frees you from having to worry
about many of the most common causes of programming errors. Because Java is a
strictly typed language, it checks your code at compile time. However, it also checks
your code at run time. In fact, many hard-to-track-down bugs that often turn up in
hard-to-reproduce run-time situations are simply impossible to create in Java.
Knowing that what you have written will behave in a predictable way under diverse
conditions is a key feature of Java.
To better understand how Java is robust, consider two of the main reasons for
program failure: memory management mistakes and mishandled exceptional
conditions (that is, run-time errors). Memory management can be a difficult, tedious
task in traditional programming environments. For example, in C/C++, the
programmer must manually allocate and free all dynamic memory. This sometimes
leads to problems, because programmers will either forget to free memory that has
been previously allocated or, worse, try to free some memory that another part of
their code is still using. Java virtually eliminates these problems by managing memory
allocation and deallocation for you. (In fact, deallocation is completely automatic,
because Java provides garbage collection for unused objects.) Exceptional conditions in
traditional environments often arise in situations such as division by zero or “file not
found,” and they must be managed with clumsy and hard-to-read constructs. Java
helps in this area by providing object-oriented exception handling. In a well-written
Java program, all run-time errors can—and should—be managed by your program.
Multithreaded
Java was designed to meet the real-world requirement of creating interactive,
networked programs. To accomplish this, Java supports multithreaded programming,
which allows you to write programs that do many things simultaneously. The Java
run-time system comes with an elegant yet sophisticated solution for multiprocess
synchronization that enables you to construct smoothly running interactive systems.
Java’s easy-to-use approach to multithreading allows you to think about the specific
behavior of your program, not the multitasking subsystem.
Architecture-Neutral
A central issue for the Java designers was that of code longevity and portability. One
of the main problems facing programmers is that no guarantee exists that if you write
a program today, it will run tomorrow—even on the same machine. Operating system
upgrades, processor upgrades, and changes in core system resources can all combine
to make a program malfunction. The Java designers made several hard decisions in the
Java language and the Java Virtual Machine in an attempt to alter this situation. Their
goal was “write once; run anywhere, any time, forever.” To a great extent, this goal
was accomplished.
Interpreted and High Performance
As described earlier, Java enables the creation of cross-platform programs by compiling
into an intermediate representation called Java bytecode. This code can be interpreted
on any system that provides a Java Virtual Machine. Most previous attempts at crossplatform
solutions have done so at the expense of performance. Other interpreted
systems, such as BASIC, Tcl, and PERL, suffer from almost insurmountable performance
deficits. Java, however, was designed to perform well on very low-power CPUs. As
explained earlier, while it is true that Java was engineered for interpretation, the Java
bytecode was carefully designed so that it would be easy to translate directly into native
machine code for very high performance by using a just-in-time compiler. Java run-time
systems that provide this feature lose none of the benefits of the platform-independent
code. “High-performance cross-platform” is no longer an oxymoron.

Distributed
Java is designed for the distributed environment of the Internet, because it handles
TCP/IP protocols. In fact, accessing a resource using a URL is not much different
from accessing a file. The original version of Java (Oak) included features for intraaddress-
space messaging. This allowed objects on two different computers to execute
procedures remotely. Java revived these interfaces in a package called Remote Method
Invocation (RMI). This feature brings an unparalleled level of abstraction to client/
server programming.
Dynamic
Java programs carry with them substantial amounts of run-time type information that
is used to verify and resolve accesses to objects at run time. This makes it possible to
dynamically link code in a safe and expedient manner. This is crucial to the robustness
of the applet environment, in which small fragments of bytecode may be dynamically
updated on a running system.

THE
JAVA
LANGUAGE