M. writes:
> If you listen to the FSF and CYGNUS, you'll hear them touting that you
> should write your software to a compiler environment such as GCC. Then,
> if GCC and the requisite tools get ported to another environment, you
> can then easily move software to that platform.

Of course this is the same message that Java tries to get across, and has
been a marketing point of "higher level" development systems like 4GLs for
a long time.

These days the whole software development and deployment world is so
chaotic and changes so rapidly under many different market forces (many
of which are in direct conflict with concepts like simplicity, stability,
and reliability) that many people like the idea of "lifting" their whole
development environment up and setting it down on top of one very good
portable tool (or a small set of such tools).

Writing to the Gnu compilers certainly has value and many people today who
have products that run on multiple operating systems use the Gnu tools on
all platforms instead of the operating system vendor's own compilers and
tools, but this is hardly a panacea for software portability since you'll
still have to deal with messy issues like the "endian"ness of each platform,
etc.

Wirt wrote:
> It seems that even those who remember history are doomed to repeat it.
> PASCAL is now remembered for merely being the first language to introduce
> structured programming -- and for a bit of time, made the elimination of
> GOTOs into a national religion. JAVA, the "write-once, run-anywhere"
> language, a phrase almost identical to PASCAL's original messge, may soon
> similarly be remembered for only have a better garbage collection
> mechanism than C++.

Perhaps, but with the passage of time the designers of Java had the advantage
of being able to learn from the failures of past attempts at portability.  I
think Java does a very credible job of being a cross platform development
tool.  It may not be perfect, but I believe it is the best thing that has yet
been developed in this area.

I think Java's most powerful message is that if you learn Java, you may
not have to learn anything else.  Here is a language and an extensive set
of runtime facilities that can potentially be used to develop all aspects
of a modern, multi-tier, multi-platform application.  Using the high end
version of Java development tools, I can sit at my PC and write all the code
for a multi-tier application that has parts on an IBM Mainframe, an HP-UX
box, an HP-3000, and PC clients.  I can push one button and all the code is
compiled and deployed to all the systems involved.  I can push another
button and the application is spun up on all the platforms at once, with
a debugger view from my PC into all the components running on all the
various systems.  I can put a breakpoint in the Java code on the mainframe,
then single step the client code running in a web browser until the breakpoint
on the mainframe is hit.  I have all the source code in front of me, and
can make a change to any level and repeat the whole cycle with a couple more
button presses.  [Ok, so I haven't personally done this yet, but all the
tools to do so are available today.]

The advantage of using one tool like this is that it avoids the "impedance
mismatch" every time your data passes from one bit of middleware to another,
and the black box (or black hole) nature of many tools and the finger
pointing issues that arise naturally from a solution that uses tools from
multiple vendors.

For any large complicated development project, it would seem difficult to
justify using anything *other* than Java these days.

A large complicated application in Java is the next best thing to a nice
little simple application written using QCTerm and an HP3000.

G.