Java and the Internet

If Java is, in fact, yet another computer programming language, you may question why it is
so important and why it is being promoted as a revolutionary step in computer
programming. The answer isn’t immediately obvious if you’re coming from a traditional
programming perspective. Although Java will solve traditional stand-alone programming
problems, the reason it is important is that it will also solve programming problems on the
World Wide Web.
What is the Web?
The Web can seem a bit of a mystery at first, with all this talk of “surfing,” “presence” and
“home pages.” There has even been a growing reaction against “Internet-mania,”
questioning the economic value and outcome of such a sweeping movement. It’s helpful to
step back and see what it really is, but to do this you must understand client/server systems,
another aspect of computing that’s full of confusing issues.
58 Thinking in Java www.BruceEckel.com
Client/Server computing
The primary idea of a client/server system is that you have a central repository of
information – some kind of data, typically in a database – that you want to distribute on
demand to some set of people or machines. A key to the client/server concept is that the
repository of information is centrally located so that it can be changed and so that those
changes will propagate out to the information consumers. Taken together, the information
repository, the software that distributes the information and the machine(s) where the
information and software reside is called the server. The software that resides on the remote
machine, and that communicates with the server, fetches the information, processes it, and
displays it on the remote machine is called the client.
The basic concept of client/server computing, then, is not so complicated. The problems arise
because you have a single server trying to serve many clients at once. Generally a database
management system is involved so the designer “balances” the layout of data into tables for
optimal use. In addition, systems often allow a client to insert new information into a server.
This means you must ensure that one client’s new data doesn’t walk over another client’s
new data, or that data isn’t lost in the process of adding it to the database. (This is called
transaction processing.) As client software changes, it must be built, debugged and installed
on the client machines, which turns out to be more complicated and expensive than you
might think. It’s especially problematic to support multiple types of computers and
operating systems. Finally, there’s the all-important performance issue: you might have
hundreds of clients making requests of your server at any one time, and so any small delay
is crucial. To minimize latency, programmers work hard to offload processing tasks, often to
the client machine but sometimes to other machines at the server site using so-called
middleware. (Middleware is also used to improve maintainability.)
So the simple idea of distributing information to people has so many layers of complexity in
implementing it that the whole problem can seem hopelessly enigmatic. And yet it’s crucial:
client/server computing accounts for roughly half of all programming activities. It’s
responsible for everything from taking orders and credit-card transactions to the
distribution of any kind of data – stock market, scientific, government – you name it. What
we’ve come up with in the past is individual solutions to individual problems, inventing a
new solution each time. These were hard to create and hard to use and the user had to learn
a new interface for each one. The entire client/server problem needs to be solved in a big
way.
The Web as a giant server
The Web is actually one giant client-server system. It’s a bit worse than that, since you have
all the servers and clients coexisting on a single network at once. You don’t need to know
that, since all you care about is connecting to and interacting with one server at a time (even
though you might be hopping around the world in your search for the correct server).
Initially it was a simple one-way process. You made a request of a server and it handed you
a file, which your machine’s browser software (i.e. the client) would interpret by formatting
onto your local machine. But in short order people began wanting to do more than just
deliver pages from a server. They wanted full client/server capability so that the client could
feed information back to the server, for example, to do database lookups on the server, to
add new information to the server or to place an order (which required more security than
the original systems offered). These are the changes we’ve been seeing in the development of
the Web.
Chapter 1: Introduction to Objects 59
The Web browser was a big step forward: the concept that one piece of information could be
displayed on any type of computer without change. However, browsers were still rather
primitive and rapidly bogged down by the demands placed on them. They weren’t
particularly interactive and tended to clog up both the server and the Internet because any
time you needed to do something that required programming you had to send information
back to the server to be processed. It could take many seconds or minutes to find out you
had misspelled something in your request. Since the browser was just a viewer it couldn’t
perform even the simplest computing tasks. (On the other hand, it was safe, since it couldn’t
execute any programs on your local machine that contained bugs or viruses.)
To solve this problem, different approaches have been taken. To begin with, graphics
standards have been enhanced to allow better animation and video within browsers. The
remainder of the problem can be solved only by incorporating the ability to run programs
on the client end, under the browser. This is called client-side programming.