When I was in high school, my trigonometry teacher posed an interesting pair
of questions:
- What's an ounce of wine in a gallon of sewage? Sewage.
- What's an ounce of sewage in a gallon of wine? Still sewage.
It turns out that this aphorism applies to Java. By now we all know that Java
is an Internet-enabled programming language and associated run-time
environment called the Java Virtual Machine or JVM. Since the JVM is now
included with most web browsers, it is fairly pervasive. That means virtually all
computers, regardless of operating system, can run all Java programs, hence
the Java slogan: "write once, run anywhere."
The key to the "write once, run anywhere" promise is the standardization of
Java. If an application is to run anywhere, Java has to be the same
everywhere.
That's where the threat comes in: some vendors (one in particular) are
attempting to add proprietary extensions to Java, or to link Java with their
proprietary systems. As soon as a programmer uses a single non-standard,
proprietary function, the application can only run on computers that support
the function. For that application, Java's portability is lost -- the wine has
turned to sewage.
For the vendor who extended Java, that's the point. Such vendors want
applications that run only their systems, so customer can buy only from them.
For some players in the industry, competition is a bad thing.
That's where
the "100% Pure Java Initiative"
comes in. Sun, IBM and other
have created this program to encourage software developers to write portable
- pure - Java programs. By using only pure Java, developers ensure that their
applications will be portable. That's good for the developer because it
increases the number of computers that can run his application. It's also good
for customers because they don't get locked into a proprietary operating
system. Remember: competition leads to lower prices.
Using pure Java doesn't come without cost. Proprietary calls lure developers
with the temptation of increased function or convenience; avoiding such calls
might lead to slightly higher development costs, or slightly less function.
To balance this temptation, customers must demand that software companies
provide pure Java applications. If customers yield to the temptation of
marginal function, developers will likely provide it at the expense of
portability, and competition will be reduced. In the long-term, reduced
competition leads to higher prices. If customers instead insist on portability,
software vendors will be supply it -- or be driven out of business. So, the
tradeoff is simple: short-term function vs. long-term cost. Today's software is
bloated anyway, so who'll really miss the function?
Java provides the industry - software companies and customer alike - an
opportunity to create a true open computing environment where software is
portable, and customers benefit from increase competition. Let's not sour the
wine with a mere ounce of sewage.
-- David Kaminsky