Slashdot Mirror
Will Linux have the same fate as Java?
geophile writes "This Boston Globe article starts out talking about Java's failure to take over the world, and then questions whether Linux will suffer the same fate. " Interesting question, and perhaps I'm being partial, but I feel as though Java promised that it was going to change the world-right then and there. Linux has been building for quite sometime, and continues to develop.
Java exists to attack Microsoft. Everybody knows this. Java is a top-down marketing strategy to hit 'em where it hurts. In a way, Java is just another closed product that claims to fit needs that Microsoft has missed. Java is essentially fighting fire with fire.
People think that Linux is just Anything But Microsoft, but it's not really. It's an organic, bottom-up movement. Linux grows into what people need and want, in a direction that provides a stable, useful tool.
This is exactly the opposite of the direction that Microsoft products take. Microsoft products grow in a direction that increases your hunger for more Microsoft products and new releases of the old ones.
Linux and GPL in general being so completely different than the MS-wares makes people believe that it's a directed attack on MS, but it's not. Linux users generally just have work to get done and Linux does it for them. I won't deny that some Linux users ALSO enjoy the Anything But Microsoft aspect of Linux, but this isn't the raison d'etre for Linux as it is for Java. Linux is like fighting fire with water.
Linux being completely different than Microsoft products, gives Microsoft little leverage to try and defeat it. The Holloween Memos show that they don't know what to do, and the "Labor Day Memo" pokes fun at the possibility of their using their standard tactics.
It should go without saying that they never support this product, fail to mention it on most of their web pages, remove all references to it from their Knowledge Base, charge exorbitant prices for it (while also distributing it free in computer books) and include the 49.7 day bug.
The obvious problem with L++ is that there would be no community support for it. If MS didn't support it heavily (as you suggest), and the Linux community wouldn't touch it (as I would guess) then it would be stillborn. Anyone who tried to make it work would give up on it almost immediately when they found they couldn't get any support for their problems.
Then, after dividing the market, there's no way Linux could sue them.
Dividing the market just isn't a problem with Linux the way it would be with Java. Java only works at all if it works exactly the same everywhere. Something called Linux works if it works anywhere. People who were interested in getting work done with a stable platform that has rich functionality (love those MS buzzwords!) in Internet applications just use some version of Linux. It doesn't hurt Linux that there are branches. If somebody sees things from two different branches that could productively brought together into one, this can be done fairly easily.
Once you've used Linux somewhere for an application it's just dirt cheap to clone that success N times. The incremental costs are often near 0 as you can use old computers that have long since been amortized down to nothing and just happen to be laying around. As MS knows from their experience of marginalizing Netscape, you just can't compete with free.
Give me a break.
1. Java is alive and well. Script kiddies won't know it, but those in the industry certainly do. Java is rapidly expanding into corporate IS/IT, server-side startup software ventures, and embedded systems. Java talent earns somewhere around 50% more on average than equivalent C/C++ talent.
2. Java doesn't suck. You only think it sucks because either you haven't really tried implementing a significant project in it (since 1.1.x), or you're a script kiddie who can't handle complying with imposed methodology. The class libs in Java are very close to object-based systems like Smalltalk. Very nice, but very strict. It's not PERL, VB, or any other script interpreted thing. It's more on a par with C++, Smalltalk, CLOS, etc.
Crusading script kiddie zealots would be well advized to embrace Java, Delphi, Oracle, Informix, ODI, or anything else enterprise level which legitimizes Linux in the enterprise. I know you hate it, but the enterprise is important to your succeeding beyond "hobbyist" status. (And save your ISP args; witness FreeBSD q.e.d)
--
This is something I've been saying for a while: Linux is great, and I've used it for a while, but it is *not* necessarily going to achieve world domination. Technological superiority doesn't always win. In the end, it's a business decision, and denying that will get us nowhere.
The possible key difference is open-sourcing. If all bugs really are shallow to a sufficient number of eyeballs, then we should continue to see far more robust software. That can impact the bottom line for lots of corporations, and thus gain substantial extra market/mind share. But as far as the individual desktop goes, Linux (while always a viable alternative) won't succeed purely on the basis of being more robust. Users need out-of-the-box hardware support and the ability to run the software they want to run, from productivity apps to home applications (read: Quicken) to, yes, games.
Java hasn't won primarily because Sun seems to have forgotten that while technologically superior doesn't always win, it is important. I carpool with a Java programmer, and whenever I make the point that Java is slow, he tells me to run a performance VM. There's the flaw: a "performance" anything should be for excellent results, not acceptable results.
Linux needs to build on its technological achievements, always improving, to win corporate share, and on its fundamental usability (HW support, apps) for individual use. That's the way to avoid the Java trap.
"You can never have too many elephants on your team."
Everyone is missing one vital point.
Linux has its place
Java was and is a great idea. Sun saw it for what it is. They marketed it, they put it out there, they tried to take over the world with it.
They got it an image problem when they stuck it into buggy browsers on slow machines, but that's a discussion for another time.
Linux didn't start out like that. Linux wasn't some germ of an idea that needed incubation and careful marketing. Linus didn't make deals with $large_software_company to include it with every copy of $popular_application. He coded it and stuck it out there.
And it stuck.
Guys, Linux has nothing to prove. The mindset is already there. The people who need to trust it most, trust it. We know when it can be used. We know when it can't. We can prove it.
Once we have that, we can work on the PHBs, and no dodgy benchmarks are going to change that.
This is not some ivory-tower dismissive. It's a reminder: in an industry awash with false promises and vapourware, Linux delivered long ago. It will remain as long as it is useful.
Dave
--
IMHO, software should be written _primarily_ with "solving the problem" in mind, with readibility/maintainability/reusability also as the foremost concerns. "Optimizing for performance" should be pretty far down on the list. That's why Java's relative slowness doesn't bother me at all.
As far as I'm concerned, the primary place one should look to improve the speed of an app is hardware. We always joke that if you want speed, don't write in Java, use C! Then some other yuckster says, "Be a real hacker, only write Assembly!"
Certainly, an experienced coder can avoid most of the common pitfalls associated with writing an app in a lower-level language. However, experienced coders are a scarce resource, and even they aren't perfect. And when you choose a language because you are optimizing _for_ performance in software, that programming style is more likely to result in buggy systems than optimizing for maintainability.
Higher-level languages generally come about to address deficiencies in the lower-level languages, and almost without exception, they carry with them a performance penalty. But, in Java's case, provided that you don't have a buggy JVM, you can be guaranteed that an app written in Java is immune to such problems as buffer overflows that are prolific in the C-application world.
So, when people tell me, "Don't use Java, it's slow," my immediate response usually starts with, "So What?"
"UNIX" is never having to say you're sorry.