Slashdot Mirror

Java is significantly better now that it was years ago. It's not slow anymore, and I can make Java look exactly like any Win XP or Linux native app in just a few lines of code. Granted, I'm not aware of any easy way (if any) to make it look like a Win 7 native app, but it's looking like it will just be a matter of time before that happens. We are writing a Java Desktop application at work, and we are even doing things like allowing the user to select the theme of the app. Java has very much improved over the last several years.

It's not just Scala. It's the new mainstream. Java of all things is getting closures in v7 (see lambda-dev mailing list for the ongoing discussion of the language changes).

On .NET front, closures have been there for 5 years now (since v2.0) in C#, and for 2 years in VB (!), and they come complete with type inference - where in Ruby you'd write something like xs.find_all {|x| x > 0}, in C# these days it's xs.Where(x => x > 0) - spot 10 differences... And then, of course, LINQ - which is just a fancy name for list comprehensions. And F#, which is explicitly designed as hybrid OO/FP from the start (unlike C#, which started as typical OO language, and FP gradually creeped in over time), much like Scala.

Then, of course, Ruby - where hybrid OO/FP style is extremely pervasive from the most fundamental libraries to all frameworks - and Python, which is more imperative in typical usage, but hey, it's got "lambda" as a keyword in it, too!

Heck, even C++0x has got closures, even if they are pretty low-level with respect to things such as lifetime of captured variables (but, they, it's C++).

Frameworks are catching up, too. A lot of new ones for .NET have APIs that are pretty much designed around the use of lambdas, even if you could, in theory, avoid them - if you try really hard. Java is lagging behind somewhat due to the lack of short and expressive syntax for closures so far (anonymous inner classes are horrendously verbose and rather limiting), but even then, the main reason why they are trying to get that into Java 7 is because there is already a line-up of libraries - most importantly, for high-level parallel programming - that pretty much need lambdas to be usable.

Oh, and Grand Central Dispatch and __block on the most popular mobile development platform today - 'nuff said.

To sum it up, if someone hasn't grokked first-class functions yet, they'll be relegated to the role of supporting legacy code in a few years or so, similar to how COBOL is handled today. Which may not be a bad thing for everyone, but still... you've been warned.

that's because there aren't any high profile web sites written in Java - they're too slow, buggy and useless. Even assuming what you say is 100% true, how come vendors patch security flaws in Java itself and they never get exploited?

We had our corporate system breached due to a flaw in a very big, expensive 'Enterprise' java web system so I know it from experience.

How about a quick google for information. This one has a table of java web framework security features. This one (pdf) describes "Our static analysis found 29 security vulnerabilities in nine large, popular open-source applications, with two of the vulnerabilities residing in widely-used Java libraries. In fact, all but one application inour benchmark suite had at least one vulnerability."

as well as "A recent penetration testing study performed by the Imperva Application Defense Center included more than 250 Web applications from e-commerce, online banking, enterprise collaboration, and supply chain management sites [54]. Their vulnerability assessment concluded that at least 92% of Web applications are vulnerable to some form of hacker attacks"

Ho hum. I guess you think Java is completely secure. What a fool. Hope no-one hires you to write any of them, well, not until you go to java.net and look up all the 'how to make your java app secure' tutorials. Sounds like "fucking morons" like you need them more than most.

I will say this in Java's favor, however: It's a language where the smartest can't write code that confuses the dumbest

Not really. They dug the grave for the dumb in 1.1 already, with inner classes; and nailed the coffin shut in 5, with generics. In 7, they are going to finally bury it with lambdas.

Me, I'm waiting eagerly to see what the next incarnation of COBOL turns out to be...

I was serious. Tail recursive call is one of the major feature lacking in the JVM. See http://blogs.sun.com/jrose/entry/tail_calls_in_the_vm http://openjdk.java.net/projects/mlvm/ And there is no way to implemnent tail-recursive call in its full generality (including tail-call optimisation to statically unknown code, e.g. thru virtual methods...) without a proper support from the JVM. This has nothing to do with addressing modes (which you don't need in a VM offering garbage collected values). And the Ocaml virtual machine bytecode does indeed show that other kind of bytecodes can be useful. JVM is not the perfect VM; it could and should be improved.

Applets used to be bad but last year it was rewritten and it's pretty fantastic now.

https://jdk6.dev.java.net/plugin2/

Well I thought, lets see how heavy this thing has become. I found the necessary magic words to install it on ubuntu from apt. And then: SPLAT! Upon trying to install it, I get this very unfriendly looking licensing message during the install!

You've identified a problem that was largely solved when Sun opened up the Java licensing scheme about 3 1/2 years ago. If you want to avoid all the silly licensing that Sun makes you go through, just use the openJDK http://openjdk.java.net/. You likely tried to install the Sun JVM.

I haven't used it myself, so I can't say how mature it is.

The Java version of Jake2 runs at around the same speed as the native C version (sometimes a little slower, sometimes a little faster):

http://download.java.net/javadesktop/plugin2/jake2/

Or an applet version: http://download.java.net/javadesktop/plugin2/jake2/

OpenID is not an SSO service. It is more like an authentication protocol and somewhat orthogonal to something like OpenSSO.

eg here is an OpenID extension for OpenSSO:
https://opensso.dev.java.net/public/extensions/openid/

Windows has been around for 25 years, and the windowing GUI probably longer (I believe Bill took the concept from Steve who took the concept from Xerox). And lets face it, Compiz does not qualify as a new type of GUI. I would love to see a brand new concepts, such as Sun's Looking Glass https://lg3d.dev.java.net/ (now defunct) (or perhaps even better ideas then that, anyone knows of any?) But it would be nice to get more innovation in that department.

I was looking into it for one of my little side projects. If you know Java and have the time to look at it, I recommend it. To call it a game server is really to limit it; it's actually a framework and server for persistent, low-latency agent-based computing. Seems to scale quite well and the API isn't too intimidating. On the website they have some showcased apps as well as case studies, but if you're really looking to find out a bit more, you should look at Project Snowman, a sample game of 3D snowmen wandering around a landscape hitting each other with snowballs.

All the same, I don't see much other use of it. Then again I think the gaming industry tends to keep its cards close to the chest (apart from rendering engines, I guess.)

I think it's a shame, but I'm not altogether surprised. At the same time, I'd be surprised if the community didn't rescue the project.

GCJ really fulfills an entirely different purpose (compilation of Java to native binaries). If you're looking for an open source alternative, you could look at IcedTea, however Java is open source now so you could just use the original.

GlassFish competes directly with Oracle AS, and Weblogic (which Oracle acquired through BEA's acquisition a while back).

NetBeans competes directly with Oracle's JDeveloper.

I wonder if Oracle will keep these tools around. Personally, I think Oracle would be a fool not to. The NetBeans/GlassFish combo is by far the most productive way to develop server side Java Applications.

Modern VMs use bytecode compiling, even on mobile platforms. Sun has even open sourced their latest implementation (see https://phoneme.dev.java.net/) C doesn't require virtual memory/exception handling, but without it any application can crash the phone or dump the whole memory map.

>Java.makes.me.want.to.claw.my.eyes.out() .NET may only be truly on windows, but it's actually not so bad to code in. I wrote a DB reporting and maint. app in C# in roughly 2 weeks, the previous version of which in Java took almost 2 months.

Good god, please learn the language and the tools and don't compain that something took you longer that on another platform.

> Crazy easy remote DB access (sure, neither are exactly rocket science, but .net was quicker and more flexible)

DB access .... please this is pathetic..... Java with JDBC drivers for every database under the sun and Hibernate is the easiest thing. No complains if you dont know the right tools. Netbeans with Hibernate / JPA class generation is very nice. Database schema updates too to reflect your entity class changes. Try that with .NETs pathetic NHibernate or other ORM tools.

> Easy installs - this had me from the start. I wasn't writing a web app, but a desktop app. The C# one was a breeze, the Java one a major headache

WTF is this? Since when is something hard to install? .... Pathetic comment.

> Attractive frontends - this will probably start yet another flamewar, but many of the java frontends are HIDEOUS

Ah... again, not knowing the tools... look around.... https://substance.dev.java.net/see.html has freaken outrageous number of look-and-feel plugins. Any swing app can be skinned. Nimbus look is my favorite.

> Performance when doing large dataset manipulations - for example, determining which server had the least free space, or which one had the most obsolete users. These are fairly trivial sorting tasks, but the java version > took probably twice as long and more memory (in my implementation, which may well have sucked to be frank).

These are comments of a retard.

> Support for dumping data into Excel and Word - this was a killer feature. I was able to generate SOX and sizing reports on the fly with C#. Java? No such luck. I never did get it working quickly and properly.

Please don't talk about things you have no idea about. We use JasperReports and it's very nice. Ah, don't give me that pathetic SSRS as an example either. Try hitting a SOAP service with that piece of shit and you'l understand. Dumping data from Excel is not a problem. We use ETL tools like Talend to extract information from Excel files and expose the information as a WebService. If you dont know of best practices and processing Excel files, dont even bother talking about it.

What about OpenJDK or Scala?

Yes, both Netbeans and Eclipse are also RCP platforms, but how many real Netbeans platform apps are there?
Well, apart from VisualVM which is a very nice profiling tool (and even included in the JDK these days) you also have the Java ME SDK (version 3.0).

But most of all, if you would have bothered to check the NetBeans website you would have found the platform showcase. So to answer your question about how many real applications: dozens, as you can see for yourself.

Not to flame; but your comments about Eclipse vs. NetBeans would have had much more impact if you would actually have done some real investigating of your own.

I'll add another thing that's missing from my N810 which looks like it's still missing from the N900, which is an 'official' JVM. The Java CDC profile was designed for devices like this - and the GPL'd Sun version is very ARM-friendly. I managed to get the foundation version up and running on my N810, but it needs quite a bit of work to get the GUI layers working (I ran into some QT3 versus QT4 threading voodoo when I tried).

So, if anyone from Nokia is reading this - I'd like to see a supported CDC personal profile JVM with Jambi support!

Yes - I know that this is all GPL'd code and I should be able to take it and fix it all myself, but having it as a standard part of the platform makes a huge difference.

I hope ARM beats x86 merely because x86 is an ancient technology that has a pile of limitations preventing the industry from moving forward as fast as it otherwise might. Previous attempts to move away from x86 failed due to the absence of software to run on the new machines. It's all fine and dandy if Microsoft write NT for the Dec Alpha and Itanium, but if there are no apps, it's pointless.

Actually there is a way for this to work. Microsoft ports Windows to Arm. Most of the time the processor is in kernel mode so that makes a difference. Now running user mode code through an emulator which is basically a big switch statement will not deliver a decent performance level. Microsoft could port their Office applications to ARM.

ARM have actually quite some experience of running non native instruction sets - Jazelle is mode where the ARM runs 80% of Java byte code natively. Basically there is an extra pipeline stage that decodes Java byte code into native ARM instructions.

Now surprisingly this doesn't give particularly good performance

http://weblogs.java.net/blog/mlam/archive/2007/02/when_is_softwar_1.html

It's actually better to JIT the code. ARM have actually have a second generation produce that uses a mixture of Ahead or Time compilation to native code for the Java platform, DBX aka Jazelle for rarely used code and JIT for the hotspots that are executed frequently. In practice I'm told that you could get by with purely AOT for the platform and JIT for the rest, except that application startup will seem sluggish.

x86 Java VMs have to do this because there is no equivalent of Jazelle DBX there. Now ARM could do something similar for netbooks. Still that is not without problems. Notebook processors, whether x86 or ARM are optimized for power consumption, not performance. Notebooks are also very short of memory - you basically can't afford to keep both the native ARM code and the original x86 code in memory. Actually there isn't much disk space either.

So it's far from clear whether an ARM that can perform as fast as an Atom on native code - i.e. a faster processor that the fastest Cortex A9 - would be able to run x86 code as fast as an Atom. Given that the performance of an Atom running x86 code is pretty awful, that makes me wonder if you could sell them even if the battery life is much better. Even that is doubtful actually - Atom is pretty power efficient but current Atom chipsets are not. It's likely that Intel will fix that problem if Arm based notebooks start to become popular though. They'll cut the price of Atoms too. At that point ARM doesn't really have any advantage over x86.

Of course I say x86 but most x86 chips will be running x86-64 code by then. ARM doesn't have a 64 bit extension either.

Java has quite nice bindings to C++ now in form of JNA ( https://jna.dev.java.net/ [java.net] ), it's actually about as powerful as .NET interop.

Yeah, there's also J/Invoke.

The problem is Java language itself. Yes, you can map unsigned ints to signed ones, pointers to longs and structs to classes, and so on - but mappings can get very complicated when API itself is (i.e. lots of nested structs/unions of arrays of pointers, etc). In C#, the type system lets you drop this level of abstraction when needed (or when it is simply inconvenient), and work with raw pointers, C-style fixed-size arrays, structs and unions with exact same memory layout - no marshaling involved. It is faster as well, obviously, since there's no need to copy data back and forth (which can cost a lot for large object graphs).

Java has quite nice bindings to C++ now in form of JNA ( https://jna.dev.java.net/ ), it's actually about as powerful as .NET interop.

Of course, managed C++ is even better still.

Layers complicate programming and create bugs? Really? As in, "the whole modular programming thing is just a fad"? If these guys can actually honestly claim that they program better in the big ball of mud paradigm, they must be super-geniuses, and trying to collaborate would be impossible for the normal geek anyway.

modules != layers

I'm a huge fan of removing extraneous abstractions, layers, extension points, gratuitous use of design patterns, silly third party libraries, etc.

In my experience, API designers biff the modeling (abstraction) and then try to hide the problems with ever more shims and layers.

Examples of my counterculture designs include DesignGridLayout, flogger, and LOX.

Alas, programmers are unimpressed by simple solutions and persist in using productivity slashing and mind gelling albatrosses.

Layers complicate programming and create bugs? Really? As in, "the whole modular programming thing is just a fad"? If these guys can actually honestly claim that they program better in the big ball of mud paradigm, they must be super-geniuses, and trying to collaborate would be impossible for the normal geek anyway.

modules != layers

I'm a huge fan of removing extraneous abstractions, layers, extension points, gratuitous use of design patterns, silly third party libraries, etc.

In my experience, API designers biff the modeling (abstraction) and then try to hide the problems with ever more shims and layers.

Examples of my counterculture designs include DesignGridLayout, flogger, and LOX.

Alas, programmers are unimpressed by simple solutions and persist in using productivity slashing and mind gelling albatrosses.

You _can_ use native packages in applets.. https://jdk6.dev.java.net/plugin2/

Wouldn't this be better to be made as a java library of some form that allows for java applets to have direct access to opengl in browser?

You mean like this?

You mean something like JOGL or LWJGL?

Been there, done that, although this is mostly for Java WebStart, not applets.

You don't have to fiddle with jars and so's/dll's anymore. Check https://jogl-demos.dev.java.net/applettest.html for a demo.

You seem to be forgetting the open jdk ( http://openjdk.java.net/ ).

Right, "Type Erasure" means that none of the semantic information is preserved in the produced bytecode or metadata.

This has several problems, for example, the following is invalid in Java:

class Stack {
        T [] storage;

        Init ()
        {
              storage = new T [20];
        }
}

You might want to read "Generic Gotchas" for Java. There is no such problem with the C# version as they are first class citizens:

http://www.ibm.com/developerworks/java/library/j-jtp01255.html

The implementation is so arcane that it requires documents like this encyclopedic FAQ:

http://www.angelikalanger.com/GenericsFAQ/JavaGenericsFAQ.html

Or even Sun's Ken Arnold stating that "Generics are a mistake":

http://weblogs.java.net/blog/arnold/archive/2005/06/generics_consid_1.html

None of this problems happen in C# and .NET.

1) http://www.theserverside.com/news/thread.tss?thread_id=46887
2) http://weblogs.java.net/blog/alexwinston/archive/2005/04/strongly_types_1.html
3) http://www.developer.com/java/other/article.php/3300881 ?
4) http://java.sun.com/j2se/1.5.0/docs/guide/language/generics.html
5) http://java.sun.com/j2se/1.5.0/docs/guide/reflection/proxy.html ?

Absent? (Admittedly, I don't code in Java, but I got those links just by googling all your points.)

He isn't out-of-date. I have to suffer Java 1.6 at my college. The VM is still slow to start, and the GUI libraries still suck.

Nah, not perfect though, but let's don't hyperbolize it either: it does not sucks really anymore. Personally I write a lot of Swing stuff and I would not say it that sucks as before Java 1.4 times. At least now 1.6 I'd say much better than even GTK or QT. Why?

Because:

• performance is same as QT or GTK. No, sorry. Performance sometimes better e.g. when you have a really huge amount of records and put it into table -- in that case I wish GTK performed better and GTK-based wxWindows did not crash.
• In Java Swing you can create any possible widget you want per a very reasonable time, having it relatively easy. Example: http://download.java.net/javadesktop/scenario/demos/repaint-NestedTest.jnlp
• While Swing looks like a cockpit of 747, yet it is over-flexible and thus very powerful. Yes, it is scary to new comers, but once you figured out, you have to say it is really cool, extendable and portable.
• To write these kind of GUIs, including Quake-2 port in QT or GTK would take much more time for you. Not saying it is impossible. I am saying about time/cost/quality/competence/final-result-asap things.
• I love JNLP concept and it works rock stable on controlled or semi-controlled networks, once done properly. JNLP (Java Web Start) is way better for internal software and enterprises than Ajax thing or equivalent GTK/QT stuff, since I've done all of this and can compare what was the best to achieve with average-skilled programmers, cheapest and fastest to develop-and-deploy. And you must know that either. :-)

Additionally, you can use your own look-and-feel (including GTK's) etc. Of course, it has its side effects: you have to emulate specific platform etc. SWT does it natively, but it suffers from portability a lot, plus some parts are written in plain Java. Since API of various platforms changes and sometimes very drastically (like Apple is gonna drop Carbon one day), SWT renders to be a fool trap that always trying to catch up current status, but actually performs great only on Windows.

Add to the story really great try of NetBeans team to bring you GUI visual editor and you have to agree that at least you can create GUI stuff literally in front of your boss's eyes. I agree, Swing not the best yet, but also not that horrible as before anymore either. That's why we can commit our patches to Java 7! :-)

I have looked at getting into bb development as well, but it is just pure hell. I have an old 8700, I can't even find out if it can run application, and I can use it as a developer platform. There is no guide on the bb website to tell anyone this, going to this shitty bb page for the 8700 reveals no useful information.

Yes, the 8700 can run applications. You need to learn how to search with google. RIM even releases free blackberry emulators so that you can test on different models. Some links for you:

http://www.blackberry.com/developers/downloads/simulators/index.shtml
http://na.blackberry.com/eng/developers/
http://www.blackberry.com/developers/downloads/
http://na.blackberry.com/eng/developers/javaappdev/javadevenv.jsp
http://today.java.net/pub/a/today/2006/01/24/introduction-to-blackberry-j2me.html
http://www.youtube.com/watch?v=AVFi39yvAr8

You can use lwuit on the blackberry. This can provide a nice UI to J2ME applications.

By the way, how does JVM deal with non-virtual methods suddenly becoming virtual when a new class gets loaded? The difference would be at call site, so does it mark all methods calling the one whose "virtualness" is affected for re-JITting on next call? Surely that does affect performance...

Any code optimized to call that method as final is decompiled on loading a class that overrides the methods. This can be done for methods that are currently executing. This is practical because Java can efficiently interpret code, so not all code has to be JIT compiled so there is little time used recompiling methods while loading many classes.

Are you saying that Jython is more popular than IronPython? Do you have any reference to back this claim? In terms of performance, I vaguely recall seeing the numbers a long time ago, and they were mostly on the same level. But IronPython seems to be developing faster than Jython...

A new release 2.5 of Jython just came out 10 days ago. As far as I can tell IronPython is basically the only language actually used to a significant degree for CLR, whereas there are several for JVM.

I don't know the current state of CLR optimizatoins, Microsoft does a good job of preventing public benchmarking, but I know that given the CLR features it's a safe bet that their optimizations are nowhere near Java's. It's just an intractable problem.

Interoperability - you've got to be kidding. One thing where .NET definitely beats the crap out of JVM, by design, is language interop. Wake me up when any version of Java will let me do dynamic invocation on Jython or JRuby objects

Invokedynamic now in jdk7. Regardless, you can call to Java objects and they can call back from all the existing languages on JVM; presumably they use reflection like the dynamic language runtime.

Of course, there's nothing precluding escape analysis in CLR, either.

Of course there is. To do escape analysis you have to analyze the code paths, usually between several methods. An object may never escape from a method with the parameters it's called with from a particular caller, but may escape with other parameters. So unless the analysis can be done on a large block of code it is unlikely to be of much help. Since Java can inline lots of methods into large blobs (because it can interpret to find hotspots) it can do escape analysis on these large blobs, considering all the paths that might be taken. C# cannot do this because (for reasons I mentioned before) it cannot really inline methods effectively.

If you've read this interview, you know that the primary reason for that design was to avoid the brittle base class problem, and any performance benefits (perceived or real) are secondary to that.

If you read the subtext, you see that performance is what was actually important. For instance, why no 'override' on extension methods? Instead they just don't get called. If they were really so concerned with correctness, why no design by contract?

A serious question: why would real generics affect JIT performance? All I've seen of them was quite positive (i.e. they get optimized on a per-instantiation basis for value types, ditto for inlining etc - quite often I could get to essentially the same code as what a C++ compiler would do for STL).

Suppose you have a List{Integer} and want to pass it to a method taking a List{Number}. In order to do this you need covariant typing or you need to construct a copy of the list. Constructing a copy may take a long time. And what if the method places a Number into the list... you can't just convert it back, and can't use a view without also doing a type check on inserts and whatnot.

And with covariant typing, where List{Integer} inherits from

Hello, it's Mr. Reading Comprehension Helper here!

The parent comment was referring to Mono being way ahead *in openness* and did not make any reference to technological progress.

(As a side note, a nitpicker would say that the "open standard" Java is standardized on its TCKs, not a reference implementation. And the TCKs are not necessarily fully open.)

If anybody can point to an actual patent that Mono or Tomboy violate, please file an issue report against the Mono project;

I know it is a bit old but, we'll file one once they publish which part they're going to patent, of course, that shouldn't be long. PS: The only complaint I have of .NET is the syntax of LINQ, but what'cha going do?

Besides, anyone thinking that MS would attacking Linux using patents isn't giving Microsoft any credit. I figure that they would try to kill Linux (GNOME proper, since GNOME != Linux) via contracts with Linux vendors as opposed to patents. It just seems too obvious to go that (patents) route. Linux isn't the problem with MS, it is more like the vendors pandering Linux that is.

Also I develop on OpenJDK, I was wondering if you could provide a list of patents that the OpenJDK is infringing on? I'm sure we could work out what it is that you feel is something we may have overlooked.

Mono is way ahead of languages like Java in that regard because, unlike Java, Mono is based on an open standard

Could you clear that up? I'm not sure I follow what you are talking about. Is it because .NET is a standard through an organized body? Whereas, Java is basically a community process with Sun at the head of the community? If this is your beef with Java then what exactly is different between how Java is made versus something like, Linux or GNU HURD?

Besides, what is all this seemingly bad blood between .NET and Java? I've been to many PDCs and the people behind .NET seem pretty accepting of Java much like the Samba - Microsoft love (which granted isn't awesome but it is still pretty good). Also, the Mono devs are pretty cool people on IRC. Really? Do we need to build walls?

Furthermore, Mono is way ahead of languages like Java in that regard because, unlike Java, Mono is based on an open standard and there are no known patents on the language core or core libraries.

Java is based on an open standard... the fully open-source reference JDK.

The reference JVM is also significantly faster than mono and somewhat faster than Microsoft CLR and has loads of somewhat useful other languages implementations that compile to it (Ruby, Python, Scala, Groovy, etc). So I'm not sure where you're pulling "way ahead" from.

i suggest reading the mailing lists of "project coin". it was very nice to read the proposals and how they have changed or rejected. http://mail.openjdk.java.net/pipermail/coin-dev/

They will add automatic resource management in Java 7. Check project coin. http://openjdk.java.net/projects/coin/

Is this a matter of your code holding references to your object, or other libraries holding references to your object?

Other libraries. You may not have a cycle between objects you control, but as soon as you expose any single one of them outside, that one can become a part of a cycle (an external object that is in a cycle holds a reference to yours), and, by extension, all objects it references. At this point, when it will die, it will die on a GC thread, when GC frees the cycle.

Then what is the right way in Java to automatically write whatever finally blocks need to be written, in the manner of Python's with statement?

Python's with statement has nothing to do with reference counting at all. It's a much simpler strategy where the programmer explicitly defines the boundary at which the resource is to be freed, irrespective of how many references there are to it. C# has a similar construct, using, which behaves much the same except for name of method that is called on block exit (__leave__ in Python, Dispose in C#), and it doesn't use reference counting at all, for any purposes.

Java actually had a bunch of proposals for a very similar thing (e.g. here is one from Google). However, none of them were accepted for Java 7 (fools...).

With the idea of native apps not being practical for the purpose of ubiquity, one would probably point to cross-platform frameworks, like Java or GTK. That's fine and good, but these things require some "coaxing", if you will, especially in the UI department. A really simple app might be work just fine, but you have to be careful about using OS-specific functions and more complex programs sometimes need to be changed substantially. Applications that use web browser technologies don't really suffer from this.

Sigh, it happens too often that people say "you have this problem with (C|C++|C#|GTK|Qt|$YOUR_FAVORITE_LANGUAGE)+ and Java".

Java has webstart since 1.4 (2001) which uses JNLP (Java Network Launching Protocol ). From the desktop user's point of view.

WS automatically downloads new versions of the software, checks java versions etc. If you want to see it work and you have Java installed (>=1.4) you can try these Java 3D examples to see how the experience is.

Are you sure? I thought it was StarOffice that was protected, but Sun was indemnifying Open Office users as well?

In any case, the agreement was back in 2004 and nothing has happened since then.

I had a thought in the past about house Sun could improve their OpenOffice development to include more outside contributors. It would be true for any of their open source projects.

One of the big issues with big companies dealing with open source projects is that they aren't required to use the public colaboration tools. In fact it's harder for them to do so.

Instead of Sally asking a question or presenting an idea to Joe on the mailing list, where everyone can see it, Sally might run into Joe in the hallway or walk up to his desk. So all these ideas that Sally and Joe are exchanging are "closed".

It may be ore productive, but it doesn't include the community.

It might be better for the community if employees working on open source projects mostly worked from home to encourage them to use the community collaboration tools.

I think Sun might understand this. The disadvantage of meeting someone in the hallway is something I heard in a presentation from a Sun employee. That might be why they have been working on the Wonderland project.

With Wonderland, you can get all the developers in one virtual conference room without having to really see or smell them which can be a very good thing. I've had my share of marathon coding sessions.

> JavaFX has been a solution looking for a problem

There certainly was a lot of energy poured into it, though. I feel bad for folks like Josh Marinacci, who has been working on it for a while. Seems like every other Java Posse episode had some mention of JavaFX and its progress (or lack thereof).

Besides, JavaFX has distinct advantages over Flash and Silverlight. It integrates seamlessly with server-side Java code. It also shares the same APIs with JavaFX Mobile, which allows mobile and RIA apps to share the same code.

The JavaFX "advantages" are promises that don't yet exist (read the comments in the link).

What are you talking about? JavaFX can already use the Java API and it already has a mobile component. The author of the link you sent me only said that work remains to be done for tooling and performance. There was no mention of work needing to be done to integrate with the Java API or the mobile component, which was introduced with JavaFX 1.1.

Get user-friendly packages of the open source version of Java 6 under the GPL2 with classpath exception here:

    http://openjdk.java.net/install/

That's Java 6, not "the next version".

There was no license to accept when I installed it on my Ubuntu box using apt-get.

Mercurial trees for both Java 6 and 7:

    http://hg.openjdk.java.net/jdk6/jdk6
    http://hg.openjdk.java.net/jdk7/jdk7

Get user-friendly packages of the open source version of Java 6 under the GPL2 with classpath exception here:

    http://openjdk.java.net/install/

That's Java 6, not "the next version".

There was no license to accept when I installed it on my Ubuntu box using apt-get.

Mercurial trees for both Java 6 and 7:

    http://hg.openjdk.java.net/jdk6/jdk6
    http://hg.openjdk.java.net/jdk7/jdk7

Get user-friendly packages of the open source version of Java 6 under the GPL2 with classpath exception here:

    http://openjdk.java.net/install/

That's Java 6, not "the next version".

There was no license to accept when I installed it on my Ubuntu box using apt-get.

Mercurial trees for both Java 6 and 7:

    http://hg.openjdk.java.net/jdk6/jdk6
    http://hg.openjdk.java.net/jdk7/jdk7

Besides, JavaFX has distinct advantages over Flash and Silverlight. It integrates seamlessly with server-side Java code. It also shares the same APIs with JavaFX Mobile, which allows mobile and RIA apps to share the same code.

The JavaFX "advantages" are promises that don't yet exist (read the comments in the link).

In distros like Fedora, which include utrace, you already can use systemtap to probe both the kernel and userspace without problems (sure, it lacks the "final polish" of dtrace, but all the hard has been done)

Really? Are there probe points for userspace method entry and exit? Is there a way for dynamic languages to add probesets like the dtrace jvm agents? I haven't seen anything like that. Got an example?

I'm looking around a bit, and this LWN article on utrace doesn't make it clear to me what actual functionality exists today.