Java and the Network Centric Future
Article by David Kaminsky, IBM Java Team Lead, and Jim Gray, IBM Fellow
As Java's applet-on-demand capability revolutionizes users' online experience and
tranforms the very notion of "personal computing," what are the implications
for the software architecture of Internet and intranet clients?
As we transition to a Network-Centric world, the concept of a "personal"
computer will mean far less. Since all of your programs and data will reside on
servers, it won't matter which computer you're using to access them. And you
won't sacrifice your individuality: your custom settings will be brought to you when
you insert your smart card into a network computer or log on to your PC. How
will such a world come to be?
Standardization on Java
Why Java? Java introduces bold new levels of dynamism. By dynamism, we mean
the ability to defer acting until an action is absolutely necessary, and then
performing the actions automatically -- you become an interested spectator, rather
than an unwilling and unhappy participant. As you'll see, it is these properties that
bring you a network centric world.
Java's dynamic download capability is the most obvious expression of Java's
dynamism. For the first time, programs can be stored on servers, and sent
automatically to your machine only when they are needed. That means that you
get the latest versions of your applications without the hassle of installing them
yourself. This capability was first used for Web "applets."
Java dynamics don't end here. Java redefines the concept of a program. With
traditional programming languages, a programmer writes his code and stores it in a
source file, compiles it into "object" modules, and links the modules into a
monolithic program. If the programmer changes even one of the modules, he has
to relink the entire application, and distribute it to everyone who is using it,
regardless of whether they were even using that particular module.
The Java programmer still writes code and compiles it into Java "class" (object)
files, but the linking is deferred until the program is run. As you execute the
application, the Java system brings in the class files that it needs, when it needs
them, from the local disk, or across the network. If you don't execute some
obscure branch of an application, that code is never brought onto your system.
To you, the program is only what you use, not what a programmer thinks you
might use. That saves download time. Even better, it means that when you execute
an application, you automatically get the latest version of each component.
Because applications aren't linked, and modules are downloaded only when
they're needed, you don't have to worry whether you have the latest version of an
application -- you do.
Together with its object-oriented nature, Java's dynamic download capability also
means that you don't have to worry about whether you have the right programs to
access the latest data. When new data comes online, corresponding Java code is
also deployed. That code knows where to find the data, and how to interact with
it. If the information moves or its format changes, the Java code is simply updated.
Furthermore, Java solves the problem of dynamically integrating data from various
sources, while maintaining a unified user experience. JavaBeans defines a structure
for object interaction. Using JavaBeans, objects defined independently can
exchange information and present a coherent interface. That's important to
companies who have a variety of back-end servers - transactional, database,
Web, and so on. Rather than writing a series of monolithic applications that draw
on these servers, programmers can first write reusable Beans that interact with the
various servers, then quickly create applications by snapping together the relevant
Beans. By leveraging composable Beans, companies can reduce their
development costs.
So there you have it: through its dynamism, Java soars over many of the barriers
to effective Network-Centric computing. Of course, we've glossed over some of
the obscure details such as cache coherence and code signing. Since the
technology exists to solve these problems, it's just a matter of time before the
solutions are applied to Java - a short time.
|