Slashdot Mirror
Beyond An Open Source Java
Karma Sucks writes "LinuxToday is featuring a intriguing article on why Sun should open source Java, as a stronger followup to the recent ESR saga that was reported here. The writer notes: 'Sun needs to do some radical things to improve its chances of survival, and all of them involve Open Source in some form or the other.' One thing the article fails to mention is the threat of Mono, which should be of special interest to Sun, with its vested interest in GNOME."
Give Away the Recipe, Open a Restaurant
Consensus is good, but informed dictatorship is better
It fails to note that these are the *most expensive* full-suites of these products that have lot of non-J2EE frills (you can get into Weblogic's base J2EE support for $10k). Other commercial J2EE application servers are well under the $10k mark (e.g. $1500 for Orion Server)
This article also fails to note that there are more than a couple very robust OpenSource implementations of J2EE application servers, that are of course free.
It's obvious that if they pointed these facts out that their argument would be weaker...
Given the state of Mono, it's not in a position to give anyone pause.
There's no motivation to "Open Source" Java. It's supported on a myriad of platforms and you can even get access to the source if you want to take on the implementation on a new platform.
The problem is the way Java is being developed and maintained as a proprietary programming language base.
There are two major Java implementations currently in use -- one by IBM, one by Sun Microsystems. Both of them may come without charge, but are without the freedom that would make them qualify as Free Software.
Therefore, all software written in Java (even software under a Free Software license) running on such a platform will "put the user's freedom at risk" (a quote from FSF/GNU people). It's like running Free Software on Windows.
If you want more detailed 411 about the status of Free Software versions of Java, hit up the following URL:
http://www.gnu.org/directory/devel/prog/java/
Reply or e-mail; don't vaguely moderate. Ex-O'Reilly/MIT employee, now a full-time Google employee.
You do realize that this is impossible, right?
No, this is not impossible. Read up on just-in-time (JIT) compliers and you'll see why. In a nutshell, the Java Virtual Machine profiles the code that is being executed, then uses sophisticated algorythms to anylize this information, then compile (while the system is running) native code from the java byte code, that is optimized for the environment, and more importantly for the ways in which the code is being invoked. Subsequent calls are executed by this newly compiled native code.
Thus the JIT compiler is able to (often) do a better job at creating optimized native code than a C++ compiler can do, because the C++ compiler doesn't have run-time analysis to use in its decisions of how to optimize the code. The JVM can continuously re-optimize the same code over and over during the life of the application. JVMs of today (and the last few years) do this as standard practice.
Qt may not be a language, but it does provide some language extensions via the Meta Object Compiler, which brings some nice things to C++. Also, Qt is not just a GUI library, but actually a whole Java-like foundation for C++. It's good stuff.
I'm not necessarily disagreeing with you, I'm just elaborating on what Qt is. It's closer to Java in nature than you might think, and with the upcoming Qt4 I can imagine it becoming quite a competitor.
You can bet diamonds to dollars that Microsoft will never open source their version though.
.Net framework and C# compiler distributed by Microsoft. It is supported on Windows, FreeBSD, and Mac OS X.
.Net framework are each ECMA standards? ECMA-334 and ECMA-335 respectively.
.Net Framework, look at the Mono Project. It is not connected to Microsoft.)
Not so. Check out Shared Source CLI, as known as Rotor. Basically a free, open-source version of the
Also check http://www.sscli.net for some SSCLI/Rotor Projects.
And did you know that C# and the
(If you want a linux version of the
I just found a new sig.
Because MySQL AB (the company) retains copyright on the software they can license it however they please. In this case, the company takes advantage of the fact that some people don't like the terms of the GPL (people wanting to build and distribute closed software that is based on MySQL) and lets a company buy a license that allows for use without the so-called "viral" properties of the GPL.
:) of the agreement. This does not preclude turning a profit on the distribution. The GPL doesn't require code to be monetarily free (aka 'as in beer'), only that you furnish, for free (or a nominal media cost), the source code of the application to whomever you distribute it.
You can use and distribute MySQL under the GPL as long as you comply with the letter (and spirit
Please explain how this would be faster than writing the app in native code using an assembler and then I'll believe you.
Ok. My assembly is a little rusty, so bear with me. Let's say we have equivalent Java and C programs. They both have to run on a 386 or higher. (Bear with me. I haven't kept up with the MMX/SSE/SSE2 instructions, so I'll have to fake this a little.) Now, your C compiler will see that you want to store a 32 bit value, but has to generate code for a 386. So, it generates the code:
pop AX
STOSW 0x0005
pop AX
STOSW 0x0005
Even though the code may be running on a Pentium Pro (which is optmized for 32 bit code), it's still going to execute those 4 statements.
Now, the Java Hotspot compiler will start and notice the fact that you're running on a Pentium Pro. So when it converts the bytecode to machine code, it creates the following instructions:
pop EAX
STOD 0x0005
That's twice as fast as the C code!
Real code would tend to be running on modern processors, so this example is a little contrived. However, the JVM can (and will) use SSE instructions to do multiple calculations in one instruction, while the C code will be forced to generate non-SSE instructions to support the old Pentium Is out there.
Hotspot is also capable of analyzing the running code and regenerating even better assembly that would perform poorly in other circumstances. For example, let's say Hotspot notices that the bounds can't be exceeded on an array. Well, Hotspot will then recompile to remove the bounds checking.
Does that explain it better?
Javascript + Nintendo DSi = DSiCade
Three specific quotes:
Q: How many people are currently JCP members?
A: The JCP has over 500 company and individual participants.
Q: What prevents Sun from controlling or dominating the groups that develop and maintain Java specifications?
A: Sun, and the other Executive Committee (EC) members, serve as technology oversight groups for the work of the Expert Groups. The ECs do not micro-manage the day-to-day workings of Expert Groups. Rather, the ECs have the opportunity to review the work of each Expert Group at well-defined points as their specifications proceed through the JCP. The primary function of the ECs is to ensure that specifications do not overlap or conflict with one another and that the specifications meet the needs of the industry segment for which they are being written.
The following EC members elected by the community during the JCP EC Elections in October and November of 2001 took office on November 20, 2001: Apache Software Foundation, Apple, BEA Systems, Borland, Caldera Systems, Cisco Systems, Compaq, Ericsson, Fujitsu Limited, HP, IBM, Insignia Solutions, IONA Technologies, Macromedia, Matsushita Electric Industrial (Panasonic), Motorola, Nokia, Oracle, PalmSource, Inc., Philips, RIM, Siemens AG, Sony, Texas Instruments, and Zucotto Wireless, as well as an individual participant, Doug Lea, representing the research and education communities
http://www.google.com/profiles/malachid
You can consider it whatever you want. However, there is an official Open Source Definition that most people mean when using the term. Also see the Debian Free Software Guidelines (DFSG). Sun's Java process, though fairly open for a commercial software product, doesn't comply with the letter or the spirit of either of these.
Sun's jvm for jdk1.5 caches JIT code in shared storage.. their 1.5 site even mentions that startup time is almost negligible now, even for large java apps.
I was rather surprised, actually, to see the amount of change from 1.4 to 1.5, at all levels: language, jdk, and jvm. The language itself has a lot of C++/C# features now like covariance and contravariance. 1.5 has more improvement over 1.4 than 1.4 over 1.1, in all aspects, imho.
Well, NIO was pretty good for what its worth.
NIO adds in some really great I/O capabilities. I absolutely love having channels/selectors for network servers. 5 hours of coding on a network server to go from single thread per connection to one thread multiplexing all of my I/O. Using a few worker threads to process incoming data and my stress testing I used before doesn't even come close to pushing the server like it used to. I had to increase the brutality of the testing quite a bit more to find top level performance.
I know I/O is just one aspect of programming, but it is VERY key to overall performance.. and in I/O bound apps NIO is a godsend.
So anyway, there were some really good improvements in 1.4. I think 1.4 was a pretty marked improvement just because of NIO.
Jeremy