Slashdot Mirror

This is a great reference article! If you are programmer working with numerical algorithms, keep this article handy.

This one too: What Every Computer Scientist Should Know About Floating-Point Arithmetic.

...for all things floating-point: What Every Computer Sceintist Should Know About Floating-Point Arithmetic. I keep a copy of this handy whenever I have to play with floats and doubles (except for the odd game of Water Tennis, of course).

Rounding towards the nearest neighbour is the default and ubiquitously used rounding mode. The complementary rounding modes (round toward -+ infinity or 0) are useful for doing calculations with interval arithmetic: a calculation can be performed twice with opposing rounding modes to derive an interval value for the result. If all operations are performed in this way, the final result of a complex calculation is expressed as an interval providing the range in which the real value will be (remember, often floating point numbers only approximate the real number). Using such a package can save you the trouble of performing error analysis. An article in the Journal of the ACM provides the details for implementing this feature.

It's marked copyright "MTV Networks", no mention of M$, but the really great part - the bookmark icon is the Netscape logo...

The bookmark icon looks like the Sun Microsystems logo, to me.

Note: When I refer to language, I mean the syntax and semantics and primitive types. When I refer to environment, I refer to the language plus any standard libraries; I am not refering to a particular VM. I think my definitions may be the source of some of the confusion, as Sun appears to want everyone to think that the java.* and javax.* libraries are part of the language. As far as I am concerned, they are just part of the standard environment. (I bend my own definition a little to include packages under the java.lang library as being part of the language, because they are object-oriented wrappers for the primitive types.)

Your original post mentioned work by Aonix on hard real-time Java. My post referred to Java features that are not able to be used in hard real-time applications. Here is my reference; granted it's a year old, but I haven't found anything newer to contradict it. The author is (or was at the time of writing) in charge of the Aonix real-time JVM.

http://www.stsc.hill.af.mil/crosstalk/2004/12/0412 Nilsen.html

Note the table of differences between traditional Java, soft real-time Java, hard real-time Java, and safety-critical Java. As you can see, hard real-time and safety-critical Java are highly restricted compared to traditional Java. Safety-critical is a subset of hard real-time that is even more strict; it requires formal proofs of safety and therefore throws out most Java features and standard libraries, leaving only the core syntax and single-threaded semantics of the language. (Well technically, safety-critical allows multiple threads but they cannot overlap, so its like single threaded programming for purposes of proofs.) Safety critical requirements are defined by FAA specification DO-178B and several JVM suppliers are working on DO-178B-compliant JVMs.

Soft real-time applications can use all (or almost all) of the Java standard libraries, whereas hard real-time applications can use only a restricted subset of the standard libraries and safety-critical applications are restricted to an even smaller subset of the standard libraries. Therefore, one great advantage of the Java environment (remember my definition of environment), its extensive standard library, is neutralized with respect to hard real-time and safety-critical applications.

Furthermore, almost all third party libraries depend on standard libraries that are forbidden under hard real-time or safety critical constraints. Therefore, these libraries are also forbidden and another great advantage of the Java environment (remember my definition of environment), the extensive field of third-party libraries, is lost to hard real-time and safety-critical applications.

The Real-Time Specification for Java defines a set of library calls and semantics which, when implemented within a general-purpose Java virtual machine.... [snip] In fact, Sun demonstrated a real-time Java application running alongside non-real-time applications on the same VM. > Note the emphasis on the word "within". Applications that implement real-time features get the JVM+RTS. Applications that do not implement real-time features fall through to use the traditional JVM. However, non-real-time applications do not automatically become real-time applications simply by being run on Java RTS. Nothing here contradicts my original assertions.

I'd like to know more about the real-time application they demonstrated. What kind of real-time application was it: soft or hard? Did you see the source code of the real-time application? If so, what libraries did it use? The link you provided didn't provide much concrete information. However, it did provide a link to Sun's official Java RTS page:

http://java.sun.com/j2se/realtime/

I am not sure how they can claim conformance for soft real-time, because they do not yet provide a real-ti

Personally I thought it was a particularly good year for Sun's Sparc processors - see this Forrester research article for example. Here are some recent Sun SPECjbb performance benchmarks against IBM's Power P5.

But since Sun isn't a leading Linux advocate, I don't expect them to get Slashdot front page coverage like IBM seems to...

http://blogs.sun.com/

Solaris seems to be faster than Linux these days, and runs on swanky new Sun Fire T2000 servers. Whether you run Linux or Solaris, file permissions are always an issue. Get used to it.

Looks like Intel is going to sink the whole planet, once the North/South pole melt.

At least Sun is going in the right direction with their new coolthread CPUs and AMD based servers:

http://www.sun.com/emrkt/trycoolthreads/

http://www.sun.com/x64/

Looks like Intel is going to sink the whole planet, once the North/South pole melt.

At least Sun is going in the right direction with their new coolthread CPUs and AMD based servers:

http://www.sun.com/emrkt/trycoolthreads/

http://www.sun.com/x64/

No parts of Java are part of an open standard.

What is not open about something you can freely download? It's easier for someone to become a member of the JCP than whatever organization does C#/CLR development. Because that's not ECMA - they just rubber-stamp whatever Microsoft and co-sponsor HP sends them.

What contract did they sign?

This one. It was settled out of court though - like practically all of Microsoft's cases.

It should be noted that Netscape also violated their license, and were duly beaten around the ears for it.

If Transmeta proved anything, it was that you get more performance-per-watt and flexibilty by moving hardware into software. I guess that was the point behind the RISC processors that are now delivering up to 32 concurrent threads in hardware. Keeping the hardware simple gives you far greater potential. In light of this, I don't see how "system on a chip" can be a good thing?

Granted this an extremely recent phenomenon, but options are appearing in the marketplace:

http://www.sun.com/desktop/index.jsp

http://h10018.www1.hp.com/wwsolutions/linux/certif ications.html

http://linux.dell.com/desktops.shtml

C# is absolutely nothing more than Java embraced and extended by MS. I'm sure you remember this lawsuit, followed just shy of three years later by this announcement.

Let's not forget that C# is the closed-source bastard stepchild of another, mostly closed-source language. What does that make Mono??

And it's only 19" deep. so that's really a lot of processing power in a small footprint.

WHo needs a rackmount microBTX system to save space and energy?

No.

Why buy from a mediocre company? See below..

[ SOURCE: Excerpt from Sun's x64 Hardware Q&A ]

Q: "HP also offers an AMD Opteron four-way processor. What's the advantage of buying from Sun?"

A: "The Sun Fire V40z server outperforms HP's AMD Opteron four-way processor-based product (the DL585). The V40z also offers a number of superior features to the DL585; for example, the V40z supports faster DDR333 memory, whereas the DL585 only supports older and slower DDR266 memory."

Given the lackluster trackrecord of previous offerings from HP, I recommend persuing Sun's implimentation of AMD x64 hardware.

Your post here is basically redundant, but I can also see you didn't read, or couldn't understand, the link.

The key is that MS was conspicuously careful that even the standardized parts of .net can be subjected to RAND terms by MS that could lock out free software. Let alone the rest of the platform, which openly locks you in.

Now compare: "If you read the license that you are granted by the Java specifications, you'll find that they give you an unrestricted blanket grant of all the patents Sun has that might be infringed by Java implementations. " -link

Everybody builds a portfolio. But do you love operator overloading so much that you'll go with someone who won't make decent arrangements with the community... And by the way who also finances fun stuff like sco? Or maybe it seems like you've just been confused?

Yes, there are quite a few on Sun's web page. Look down at the bottom of this page: http://www.sun.com/software/solaris/index.jsp Sun has over $5B in the bank, they are not going anywhere. They are the largest supplier of computers to the US Gov't. Comparing Standard plans, RHEL is about $799/yr maintenance. AIX is $299. (IBM web site). Solaris 10 is $240 (Sun web site) However, there ARE a lot of small shops that will use the 'Net as the source for Maintenance. RIsky in my opinon. Linux works very well as web/print servers. Lightweight tasks it handles well. Actually SMPs still are hot, there are problems where it fits well. Oracle runs just fine on SMPs or on distributed. You really need to know more about HOW a company uses Oracle to tell which way they should go. Beowolf clusters where all the machines are connected in a "network" and the scheduling is managed centrally. That's good for problems that can be broken into parallel threads that can come back together (synchronize) as needed. I can't think of a General Purpose business problem that can be that parallelized to take advantage of this approach. There are certainly problems in Science that can be done this way. Genetics comes to mind. Graphics (high end rendering) can also benefit.

I don't know what you uconsider low cost workstations, but something starting at 5,575 doesn't seem to qualify as low cost. If you want to run a real Unix on a supported platform Sun's workstations start out a lot cheaper and similarly loaded workstations are cheaper. http://store.sun.com/CMTemplate/CEServlet?process= SunStore&cmdViewProduct_CP&catid=48612 AMD workstations start out as little as 895 and UltraSparc based workstations go for as little as 1,395. They can run Solaris 10 as well as RedHat and Suse. Similarly, you can get Sparc and AMD based servers from Sun for under a grand. Being able to run multiple lpars may be cost effective if you want to run multiple lpars but if you want to have one affordable server for development.

/**
  * Returns the foo of the object.
  * @return the foo
  */
  public Foo getFoo() {
    return foo;
  }

public void strawman(String amateur) {
    for(String part : amateur.split(" ")) {
        System.out.println(part);
    }
}

Furthermore, he gives Ruby an attaboy for allowing him to define both classes in one file. I'm not sure why that would be terribly important to him, but it can be done rather simply in java too. The rule is one public class per file. There's nothing wrong with multiple package classes in the same file, so if you aren't producing a library for others to use, write your whole darned program in one file if that floats your boat. He could even do multiple public classes by making them inner classes of the named class. But honestly, I don't understand why packing two classes into one file qualifies as a major achievement. Finally, when he gets into the filtering code, I notice a glaring omission; Import statements of some kind. Am I to understand it's back to C style name collisions with Ruby?

Aside from showing how 'terse' Ruby can be, about the only praise he has for the language is that it is dynamically typed. In other words, you don't need a Java interface to call a method. I can still do that in Java with reflection: java.lang.reflect.Method Strong typing isn't the huge PITA a lot of people try to make it out to be. Casting and RTTI gets old sure. If you're doing a lot of casting and RTTI though, then it's a pretty good sign that you need to refactor your code.

I'm not trying to pooh pooh Ruby here guys, but this doesn't seem like a very persuasive sermon to convert all the Java programmers of the world. In short, I still fail to see what all the fuss is about.

Alas, in the real world where 32 parallel application hardware threads might be churning away day and night, threads are the way working people handle this kind of parallellism, where one thread might know of the context of work arriving, but nothing of the content, as threads are just as transparent as the tools we handle them with allow them to be.

So I ask again: what size of real world parallel applications do you usually design and implement?

Um, because the JVM is fucking slow

get real. It benchmarks close to C++ speed. For example, a version of Quake has just been released in Java that is as fast as the C version.

The reason for using languages on the JVM is that they can gain a substantial fraction of this speed. Open-source VMs for languages like Ruby are far from complete and fast (so far).

Rather than emitting Java bytecode from other languages, wouldn't the more useful effort be to improve generation of machine code from Java source and class libraries?

Why bother when the JVM emits highly optimised native code for whatever platform you deploy on?

Choose an easy ide(Integrated Development Environment) to use that has autolisting of members to make things easy. i.e sharpdevelop (C#) or eclipse (java).
For java I would recommend the java programmers reference by grant palmer as if you have the question (ie how do I read a file) you can look this up.
just remember you can always ask the net (i.e type a question into google) if you want to do something. Like how do I use dates in java.
Other than that if you want the basic totorial sun has one on java online: turorial
for c# I am sure someone will answer something

I've been using java for three years or so now. Trust me, you'll love the Java API. With it, before you write anything check whether it's already a part of the API. As far as I know, C# doesn't have anything like it. Plus with java, you get much more open source code and examples. Especially useful for things like MySQL / ODBC / JDBC connectivity open source.
 
  And if you need native code for speed, you can usually compile it with visual J#.

It's been pointed out elsewhere in the thread, but you can download the Java source yourself from http://java.sun.com/j2se/1.5.0/download.jsp It's a rather restrictive license, so I wouldn't go so far as to call it 'open source', but it's certainly not 'closed'.

This is a bit long-winded and I fear not totally coherent, but here you go:

The reason is that currently immutable collection classes must either forsake using the Collection interface (thus giving up compatibility with existing objects that demand a Collection, such as Collections.binarySearch() (okay, the latter takes a List, but same idea)) or must provide dummy implementations of functions such as add() and remove(). The latter functions can do nothing (so just public void add(Object o) { } essentially) or throw an exception. (Okay, so there are other options too, but those are probably the most appealing ones, and, in fact, the Java API says that "The 'destructive' [mutating] methods contained in this interface ... are specified to throw UnsupportedOperationException if this collection does not support the operation.")

The reason that it's important that the objects throw an exception in these methods is that if you call a method that calls, say, add(), that method probably depends on add() succeeding. If add() doesn't succeed and doesn't signal its failure, the calling method might break, enter an infinite loop, etc.

However, this leads us into the situation of having a method that always throws an exception. My claim is that this is a bad state to be in, and that that method would be better off implemented. The reason is that if the method isn't present then the compiler can detect the problem. If I write someImmutableCollection.add(foo), the compiler will yell and say "ImmutableCollection doesn't have a method add." But if I write someCollection.add(foo) where someCollection is a type that implements add() as a throw-only method, the compiler will happily accept it. (At least probably; in this case it's possible to detect it statically. However, in the following case it isn't.) Note that it's still a bug; if that line runs the app will break.

But it gets worse. Because if a method bar() takes a Collection as a parameter, it might call add(). In that case, you can't call bar() with an immutable collection. But the compiler will let you. And, unlike in the last case, it's essentially completely impractical for a compiler to try to detect this.

What this all comes down to is that something that the compiler could tell you easily with a better design has been moved so that it won't be detected until you either run the code (and maybe not always -- perhaps it's a transient bug!) or review it, and neither of those are guranteed to happen. (It's the same reason programs such as Lint have been developed, and why compilers give you warnings.)

(One other comment I have goes back to the JFrame.add() method that originally brought this up. I was working on a program and ran into that design issue. But problem was that it works in 1.5, which is what I was using to develop with. But 1.5 binaries are backward compatible with the JRE 1.4 runtime, so I sent out the binary to other people in my group who then hit the bug. They still would have hit it if it were a compile-time thing because they would have probably had to recompile, but it goes back to a sure thing vs. a not sure thing. Stuff like the library incompatibilities decrease the chance, however small, that these bugs will be found.)

Finally is just the documentation aspect. If I call a method that takes an ImmutableCollection, I *KNOW* it won't add anything to the collection. I know that there isn't a bug in the method that will add something; I know that the documentation in that regard is up-to-date because the documentation IS The code, etc.

(I'll also point out that the particular case I'm talking about could also be rectified by providing something akin to C++'s const. Then ImmutableCollection becomes const Collection, size() and the other non-mutating functions are marked const, add() and the other mutating functions are not marked const, and voila. However, there are still other places where this principal can be applied. There are places where the cost of applying them is prohibitive compared to the benefits though.)

and did you forget that i have to buy an entire worthless operating system just to run this damn visual studio ?

The majority of the world is using that particular worthless operating system. If you program for that platform, you may want it available for testing.

i'd go with java, but not because of the cost, but because java will be the same after 3 years whereas the next versions of C# will probably blow the current version away.

Are you sure that Java never changes?

Java is also a good choice if you want to buy http://www.apple.com/macosx/features/java/>some hardware that comes with a free* IDE.

Just a note on the poor trig performance. Java goes for accuracy over speed when dealing with large multiples of pi (for -pi/4 to pi/4 the performance is much faster). James Gosling has a whole discussion on the issue here. It would have been nice if Java offered the option of a faster, inaccurate method for trig functions, but if you really don't care about accuracy and would prefer speed you probably want to do table interpolation anyway.

Derek

JIT compilation wasn't always there. In fact, it wasn't included until Java 1.1.6, released in April of 1998. Everything Java-based before that was interpreted, SLOWLY. Interpreted ASP would have had very similar performance characteristics to JSP before JIT became widespread and stable (circa 2000?).

It's been a few years... thank heavens sun keeps copies of their proxy statements on their site:
http://www.sun.com/aboutsun/investor/annual_report s/proxy_statement_03.pdf (page 34 and 35)

Note especially that the board recommended that we vote against it... which a majority did... then I sold my shares.

That's a shame. I just downloaded the newest JDK (5.0), and started playing with the IDE, netbeans (comes in the same package), which has a very nice quick-start tutorial, and frankly, I'm impressed. It's not all intuitive, but the richness of it means I don't hit walls too hard, the way I did the first 3 times I tried MS Visual whatever.

I guess I'll just have to get things done without being part of a madding crowd, then...

...is to just pick up a Sun Ultra 20. It comes with the latest development tools for Java (including an app server), C, C++ and FORTRAN, and is a peppy box to boot. You also get three years of support for the included tools, and it'll run Solaris 10, Linux and Windows. It's also reasonably priced, all things considered.

Indeed. I'd ask what the Python and Ruby counterparts to, say java.util.concurrent.ConcurrentHashMap or java.util.concurrent.SynchronousQueue are, if I didn't know about the Global Interpreter Lock which quite effectively limits any serious adult use, outside of the sandbox where wild imaginations roam free and little shovels and sand cakes seem to do anything anyone might ever want.

Indeed. I'd ask what the Python and Ruby counterparts to, say java.util.concurrent.ConcurrentHashMap or java.util.concurrent.SynchronousQueue are, if I didn't know about the Global Interpreter Lock which quite effectively limits any serious adult use, outside of the sandbox where wild imaginations roam free and little shovels and sand cakes seem to do anything anyone might ever want.

Those things are a bit weird. They look like X terminals but they are "not", weirdly it looks like they are at least friends of X terminals as xmodmap works in a manner.

Take a look at this entry. It looks like xmodmap works on the sunray except for when you switch terminals *if* the terminal has a different keyboard mapping.

You may need to run xmodmap .xmodmaprc as a startup script for gnome/jds3 as they mention as well.

I'm curious if this works.

If you get that working, there should be way of running that script whenever you "hotdesk" to a new terminal and fixing the keyboard flush (by keeping the previous keyboards country code in a file and comparing that to the new keyboards countrycode).

What is a bit funny about this thread is when I added the addendum about the ctrl-capslock swap doesn't work on the mac machines, people pointed out they finally fixed that feature w/ 10.4 when they replied to my post. So what is fantastic is I now finally have my powerbook w/ the capslock ctrl swapped like the sun keyboards :)

ahh heaven :)

Oh yeah, I know about Xmodmap. Used to be the first thing I'd install when I was setting up a Sun workstation. Alas, it doesn't work on the evil Sun Ray terminals Sun now forces all its non-developer employees to use. Notice I said "terminals". Officially it's a "thin client", but it doesn't do anything that fits in the client-server model. It's just a graphics terminal, with all the actual computing taking place on a central host. Yes, Time-Sharing is back!

PHP programming is becomming about the libraries. Smartyhttp://smarty.php.net/ - a template library makes putting coherent websites together easier. Although it doesn't do anything for the database part of the site, its one less thing to worry about.

  PEAR confused me and I was programming before it so I have my own libraries. The php web documentation is excellent.

although the java studio creator is now free, and seems like an amazing tool, its not enough to get me away from php
http://developers.sun.com/prodtech/javatools/jscre ator/reference/quicktour/2/flash/index.html

I know bashing Sun in general and Java in particular is almost as popular as bashing Microsoft here on /. But if you want to play with 3D desktop ideas you could do an awful lot worse then Project Looking Glass which Sun kicked off a while ago as an open source project and is already quite advanced. There is quite a fun demo of it here

I just tried on another system Konqueror in Mandriva distro - KDE 3.4.2, and the browser did not have kerning too, or at least I did not found any in the particular font. I do not know what is the reason, it might perhaps be some that particular font issue.

In Java, lacking kerning support for text layout was a bug that lasted until the version 1.6, that is yet experimental: http://bugs.sun.com/bugdatabase/view_bug.do;:YfiG? bug_id=4339577

Anyway, it's nice that the kerning is getting supported, thanks for the info.

Sun managed to set up Trusted Solaris to deal with this a few years back. Having each virtual host have its own sandbox is the way to go.

http://www.sun.com/blueprints/0202/trustedsoe.pdf

I'm waiting fot the day when Linux distros do this out of the box.

1. This means you have a dedicated admin machine that only a few very trustworthy admins have access to, that is very secure (no root logins, firewalled heavily, patched often, etc). I highly recommend running SuSE Enterprise Linux 9 with the IBM EAL4+ Security Configuration
   All maintenance activities are run from this management server.
2. Use the Parallel Distributed SHell (PDSH) utilities: http://www.llnl.gov/linux/pdsh/pdsh.html. These allow you run commands or copy files to a single system, a group of systems, or all systems at the same time. Wondering what kernel all your systems are running? Just issue a `pdsh -a uname -a`. Need to copy out the sudoers file? `pdcp -a /home/admin/node_files/sudoers /etc/sudoers`
3. Run Ganglia for resource monitoring: http://ganglia.info/
4. Run Samhain for filesystem integrity scanning on all servers: http://la-samhna.de/samhain/
5. Host based firewalls for all servers: http://www.shorewall.net/
6. Power supplies have caused more instability in my experience than any other single hardware component. Buy both good equipment and buy systems with dual redundant hot-swappable power supplies for the important machines
7. Good deals can be had from the big vendors. Although we run a lot of whitebox and IBM equipment, Sun currently has a great system for a very cheap price (starts at $745): http://www.sun.com/servers/entry/x2100/.
8. NFS sucks, but is the best filesystem glue-layer available. It is very sensitive to high latency environments, so run it over Infiniband (it has very low latency, and massive bandwidth (5us, 1.25GB/s) if you need to sqeeze out the best performance.
9. Every system should have an electronic "system book", which contains the full hardware specs, including where each part gets service from (if bought separately), how long the warranty lasts (give end dates), contact info, etc. If you are managing 50 or less systems, keep track of all changes in a central location, otherwise track all changes by using a system which scales (even a handwritten script and DB table would be sufficient).
10. Good enough is the enemy of the Best, but that is a good thing. Never overengineer a solution, this only means that other problems go unsolved.

Monospaced, in Java, is a Logical font. See here:

http://java.sun.com/j2se/1.4.2/docs/api/java/awt/F ont.html

Logical fonts are the five font families defined by the Java platform which must be supported by any Java runtime environment: Serif, SansSerif, Monospaced, Dialog, and DialogInput. These logical fonts are not actual font libraries. Instead, the logical font names are mapped to physical fonts by the Java runtime environment. The mapping is implementation and usually locale dependent, so the look and the metrics provided by them vary. Typically, each logical font name maps to several physical fonts in order to cover a large range of characters.

A physical font is what you should use to ensure the same font is used across platforms. And since each platform might not have that font, you should probably include it yourself.

I just installed Tomcat from JPackage on Fedora and it was painful because Sun makes it difficult to automate the installation of the basic Java foundation. I have to click through a license to download it, then click through it again to unpack it, then assemble an RPM, then install the RPM. And I have to repeat this for multiple packages (eg. Javamail) before I have enough that I can let the rest of the open source packages from JPackage download and install on top without further interaction.

Then Sun fails to structure its Java to fit the Linux Standard Base (LSB) Filesystem Hierarchy Standard (FHS) so JPackage must provide an adapter package that symlinks all the Sun files to the correct locations.

background threads don't help with CPU intensive work on single processor boxes.

If you know enough about thread management to enter this conversation, then you would know about thread priority settings.

the GC and the JIT'er take CPU cycles, (and lots of them).

What takes lots of CPU cycles is poor design. If you find that you're creating and disposing of objects over-and-over again, such that your memory manager is kept noticeably busy, then it is time to revist your design, whatever the language. Simple memory-management in C++ can mask bad design, because inline malloc/dealloc (vs. the GC) will spread the task over time, instead of bunching it together like Java (on a properly prioritized background thread :), making it less noticeable, even though it might be a similar percent of CPU cycles utilized.

Good reading to this end:

Effective Java
Effective C++

The other thing is, when you use Java J2SE classes from the built-in libraries, you're working with sometimes very general-purpose classes, designed to handle lots of situations. General purpose can equal slow performance. If you want better performance, write better code, specific to the task at hand.

Also realize that Strings in Java are not at all like char[] in C++. Like I said, general purpose classes can be slow. You're better off rolling your own, at times.

Cheers.

have to agree with Mr. Decaff there. Garbage collection has gotten more advanced using things such as incremental GC. Also, specialized VMs such as from bea (look for JRockit) use advanced techniques such as multiple GCs.

Also the article mentions:

For one, many of the now-large companies built from the ground up to operate on the Internet don't make Java a major piece of their tech strategy. Those include Google (GOOG) and Yahoo! (YHOO).

In this article, Li Moore (software engineer at Google) says: "Google makes extensive use of the Java platform. Large parts of popular Google products are written in Java. We also use Java in many internal systems and products under development." So, this would seem to be entirely untrue in Google. I wish people would do a bit of research, instead of speculate/lie (which are, of course, easier to do).

Finally, I notice that the author of the article asks Peter Yared and Marc Andreessen their opinion. What sort of answer would one expect from the CEO and chairman (respectively) of competing technology companies? Naturally, they would champion their own technology and bash a competitor. I certainly would if I were in their shoes!

What the fuck is JAVA? It's bloody Java. Why are you randomly capitalising THE letters in a WORD? Java has never ever been an acronym. I doubt you could find a single reference to JAVA on http://java.sun.com/.