21 Sep
1998
21 Sep
'98
5:43 a.m.
Someone wrote:
> Java is the closest thing we've got today to
an architecture-neutral
> executable environment.
Except for the fact that it pretty much requires that IEEE floating point be
used. Yes, Virginia, there are lots of machines out there that don't
do IEEE math! And there are many good reasons to *not* use IEEE floating
point.
William Donzelli pointed out:
C is well established, Java is not.
True, but C itself if far from portable. The endless maze of #ifdef's
that are necessary to make a piece of source code portable among a limited
set of machines and OS's are fine and dandy unless you have to support all
those different permutations!
People keep worrying about what the
different companies will do to extend or change Java. When Java gets to be
a truely standard, then I might say OK.
Part of the problem is that folks are already using Java in ways that
are not portable. It's almost as bad as those web pages that come up
and *insist* that you change your graphics mode to 640x480 or
some other particular size - why do folks insist on starting with a
nice general information-based document standard and then turn it into
a nonportable one???!!! At least, in my experience, any page that
insists on being viewed at some particular resolution inevitably has
absolutely zero information content, so I don't want to view it anyway.
--
Tim Shoppa Email: shoppa(a)trailing-edge.com
Trailing Edge Technology Voice: 301-767-5917
7328 Bradley Blvd Fax: 301-767-5927
Bethesda, MD, USA 20817
21 Sep
21 Sep
5:21 a.m.
It was thus said that the Great CLASSICCMP(a)trailing-edge.com once stated:
William Donzelli pointed out:
As a software geek, C is quite portable, as long as you keep several
things in mind, like shorts are at least 16 bits, longs are at least 32
bits, ints are at least 16 bits and can't be longer than a long, and don't
use functions not defined in the Standard C library (or stuff you've
written).
It's only when you strive for solid, reliable robust code that you have to
skip past the Standard C library and that's when you start having all those
insipid #ifdef's all over the place. It takes experience and some skill to
deal with that stuff cleanly [1].
C is well established, Java is not.
True, but C itself if far from portable. The endless maze of #ifdef's
that are necessary to make a piece of source code portable among a limited
set of machines and OS's are fine and dandy unless you have to support all
those different permutations! It's almost as bad as those web pages that come
up
and *insist* that you change your graphics mode to 640x480 or
some other particular size - why do folks insist on starting with a
nice general information-based document standard and then turn it into
a nonportable one???!!!
They spend an inordinate amount of time getting the stuff to look decent
on *their* system and they assume everyone has the same set up. Also (as
far as coding goes) it's easier to write non-portable code than it is
portable [2]. Sorry. Unless the content is very compelling, if I can't
read it, I'll move on.
-spc (Heretic programmer and computer crumudgeon ... )
[1] Basically, it comes down to abstraction. If you can hide the
non-portable stuff within a function you have a better chance of
dealing with more ports. A program I wrote [3] for Unix needed
a few functions changed (about 4) to run successfully under
Windows.
[2] Actually, it's pretty easy, as long as you plan from the start to
make the program portable. But I'm afraid most programmers don't
design as much as hack away at things. Linux was like that, and
it took about three years to get it ``portable.'' I would like
for students in CS departments to be forced to write code for
two or more different platforms, but alas, I doubt that'll every
come to pass.
[3] It's actually a CGI program in C that's being turned into a stand-
alone program for Windows. You can play with it at
http://www.geofind.com/
3:10 p.m.
At 10:43 AM 21-09-98 -0400, CLASSICCMP(a)timaxp.trailing-edge.com wrote:
Someone wrote:
Well, if you want to do something reasonably portable (I was about to write
portable, but someone will provide a nice counter example :-) you could
write it in a language that has a compiler written in itself that generates
pseudo-code. Two examples come to mind, Pascal and BCPL (me, I prefer the
latter, but what the heck).
You then write an interpreter for the pseudo-code in anything handy (the
BCPL one I have is written in c, but it's about a day's work to rewrite in
some other high level language. Took about 2 weeks way back when to write
macros to convert intcode (the BCPL pseudo-code) to 8080 assembler, and
then about a week to assemble a simple program on my Northstar :-)). Then
you have a relatively portable environment that you can take with you
wherever you go. I have versions of the BCPL compiler running on VMS,
Digital Unix, Linux and NT. My one major BCPL program works in all these
environments (it's my basic test of correctness other than the compiler
itself).
Further info at http://www.idiom.com/free-compilers/LANG/BCPL-1.html
Huw Davies | e-mail: Huw.Davies(a)latrobe.edu.au
Information Technology Services | Phone: +61 3 9479 1550 Fax: +61 3 9479
1999
La Trobe University | "If God had wanted soccer played in the
Melbourne Australia 3083 | air, the sky would be painted green"
> Java is the closest thing we've got today
to an architecture-neutral
> executable environment.
Except for the fact that it pretty much requires that IEEE floating point be
used. Yes, Virginia, there are lots of machines out there that don't
do IEEE math! And there are many good reasons to *not* use IEEE floating
point.
William Donzelli pointed out:
> C is well established, Java is not. 
3:21 p.m.
On Tue, 22 Sep 1998, Huw Davies wrote:
Well, if you want to do something reasonably portable
(I was about to write
portable, but someone will provide a nice counter example :-) you could
write it in a language that has a compiler written in itself that generates
pseudo-code. Two examples come to mind, Pascal and BCPL (me, I prefer the
latter, but what the heck).
Excellent idea! That's part of the reason to choose Java :-) Sun's Java
compiler is written in Java, and generates code for the Java virtual
machine. Most of the Java runtime environment is also written in Java,
except for the machine-level glue which is written in a combo of C and
assembler.
I'm sure future generation won't have to worry about performance of the
JVM, but for users that have that concern today, many Java compilers can
also compile down to native code (not to mention JIT).
I'm not a big Java fan for most applications, but for certain niches it's
a great idea.
-- Doug
9431
days inactive
9431
days old
3 comments
4 participants
participants (4)
-
CLASSICCMP＠timaxp.trailing-edge.com -
H.Davies＠latrobe.edu.au -
spc＠armigeron.com -
yowza＠yowza.com