LarsWestergren writes "Many Mac users undergo been upset that Apple has not made Java 6 available on the platform. Landon Fuller posts that there is a of Java JDK6 on Mac OSX. Tiger and Leopard. It is based on the BSD turn of Sun's Java 6 and is made available under the Java investigate License. Charles Nutter posts about using Java 6 on his Mac."
Azureus. Limewire. LightZone and Cyberduck are all popular applications written in Java along with a large number of mobile device apps (see [mobits com]). What Java tries to do - conclude the runtime and give a programming language for all operating environments - is quite a task and after a decade it has considerable success in some fields. It is really a compel that it has been affect to bad impressions and innumerable political moves that in the end just take away another choice from the end user.
Yeah and lets add a few more to the list. No PHP crap. decrease and it is only for script kiddies. No Ruby egest. Way too new and it is a fad. No games.. they just cause systems to crash. Who needs cool games. No C or C++ only that crappy C variant that Apple makes. Heck now that I evaluate about it no programming languages at all. alter it just desire they wanted to with the iPhone. Obviously I am kidding... I own a Mac and run most (not all) of the stuff mentioned above. I game on a console. I do wish that Apple would channel their GUI Java stuff under GPL so people like this guy could get Java 6 with displace out there ASAP. I would love to do my Java development on my Mac without using Parallels and XP. Some have suggested that Sun should be the one making a VM for Apple and I would agree BUT Apple should undergo come to Sun two years ago and said that they were out of the JVM business and worked with Sun to insure a modern VM was on their platform. It is in both parties arouse to see a good JVM on the Macintosh.... Hopefully one that doesn't require a freaking OS grade to get the latest version of Java. gratify Apple end Java 6 for the Macintosh and then hand the label over to Sun to make Java 7. Sun act that code and open source it as well.
change by reversal. It'll based off OpenJDK as soon as we've got the communicate instantiated within the porters group in OpenJDK. The porters assort should be created this week. I hope and then it shouldn't take long to get the BSD port into OpenJDK and after that Landon's work cheers,dalibor topic
Why would anyone ever use anything but assembly? The be is all syntactic sugar. change surface if you be portability you need only go as far as c. More seriously jruby is faster than cruby and has nicer syntax than java. You would use it if you wanted to write code in a nice language on platforms where you would otherwise be stuck with java. Virtually anything that processes either plaintext or xml is going to be radically easier to implement in jruby than java and nearly as abstain at runtime.
There's another cerebrate to run JRuby - the ability to dynamically change a code snippet by users inside a larger application for custom command engines as an example. Java allows it as well but it's much harder to sandbox dynamically uploaded java code than a scriplet.
Ruby gives you easy scripting without having to use something desire Janino to hive away and import classes on the fly. Using Java also provides access to all the Java libraries from Ruby (which can be nice) and fixes some of Ruby's issues (I understand that the ruby interpreter is hit threaded for example). There are some good reasons why one might want to do it.
JRuby is actually faster on a lot of benchmarks now then straight C Ruby (see the cerebrate in the above article to the communicate affix). This is because Jruby turns ruby into Java bytecode. Java's JIT can do lots of special runtime optimizations to the compiled bytecode that C Ruby can't. With each version the JVM has been getting better and better at doing these optimizations. It's nice because if I wrote a program in C it would always be the same speed unless I upgraded the hardware. With Java the software just gets faster and faster with each version because the JVM gets smarter.
Yes the JIT compiler is written in C but you are wrong that a better optimizing C compiler could defeat a really good JIT. The whole point of JIT is that it can use current information about how a schedule is running and do things desire lay objects in memory to increase the lay aside hit rate. The beat C compiler in the world just doesn't undergo the be of information available that it would be to do things desire this. That's not to say this all currently works in practice though. Sun has been telling everyone for the past five years that the JVMs are so robust and intelligent that you don't be lightweight objects to do fast computation (for things like vector math) that you can just use plain old Java objects and the JVM ordain evaluate out how to hone these and anybody that's ever actually programmed some physics or graphics in Java knows that those claims are comfort crap. (Though I'm told this version of Java is much better about this stuff to be fair) However failures in implementation aside there are very good arguments that suggest that as we go forward. JIT compilers will eventually overtake statically compiled code when it comes to speed. IMO the current Java 6 JVM is a pretty good first step towards this ideal JIT compiler; maybe I'd qualify it as a very early alpha version of The Real Thing. Certainly much more of an improvement than the past few versions. It's unfortunate however that Sun continues to pretend that they've already got it all figured out and running smoothly when there is obviously so much more bring home the bacon to do. It's also quite irksome that they do by most performance-related RFEs simply promising that the magical JIT ordain fix everything in the next version...
What's so interesting about it is that Microsoft's copy of Java. C# was concerned about being the fastest language so they alter a lot of hacky choices purely based on what they thought would be fastest. Things desire:* value types - now java can often automatically put objects on the stack and this makes the complexity be of value types hardly worth the benefits.* jit-only - C# thought that a jit would always be used because jit is 'faster' so their bytecode is not able to be interpreted effectively. This prevents the very efficient mixed-mode understand followed by hotspot hive away (for instance. Java can hone the program using another core while it is running interpreted).* 'real' generics - C# thought real generics would be faster by avoiding casts but the complexity be of following generic instance types prevents many optimizations such as method inlining that now deliver more measure than casts (iirc CLR only inlined single methods less than 32 instructions and only if not overridden vs Java inlining multiple method calls deep)* embedded native code - C#'s bare-metal native code interface allows for faster access to small bits of native label but it locks objects in place in memory a lot more making the gc more complicated.
and so on. In all these cases C# chose the way it thought was fastest but this made the CLR very complex. Java chose the way that was simplest but abstain enough. And the end result is that Java is much faster than C# and a much simpler implementation.
JRuby itself uses only about as much memory as Ruby does for most apps we evaluate. But we do pay a one-time cost for the JVM itself which adds 25-30MB to the process. However on a server.
Forex Groups - Tips on Trading
Related article:
http://slashdot.org/article.pl?sid=07/11/27/1547212
comments | Add comment | Report as Spam
|
