So Delta has a cute “We’re Experiencing Some Turbulence” error message when they have an internal error on their website. I’ve seen this error many times before, I think the first time I chuckled a bit.

The other day I was enjoying the new Wi-Fi Delta offers in some of their flights. I checked my email, my facebook account, everything worked great. Then it occured to me to check my delta account. I was wondering if they credit your miles after take off or later when you land (yeah I was bored). Suddenly, I get the familiar error message; “We’re Experiencing Some Turbulence“. I go, “oh crap” what’s going on? For a couple of seconds I forgot I was getting an error message for a website, and thought I was reading a message about my flight, a problem serious enough that they bothered to notify me via the new Wi-Fi connection.

Now I did say it was a couple of seconds, of course I quickly realized this had nothing to do with my flight. But for a couple of seconds I did get a bit freaked out by the message, specially seeing it on my browser. It got me thinking; how did my brain go into alert mode that quick when I know better?

It was all about context.

The context in this situation is this; traveling on Delta flight, on the official Delta website, checking my account and current flight information and then getting a message mentioning a very specific phrase about air travel. Obviously, if I get this message at my home, the train or the airport there’s no problem. Everything changes once I’m on a situation that is directly related to the term used in the error message.

So it’s probably not a good idea to keep these cute error messages, when you think that there’s a new context for use of this site. Before it wasn’t possible to read this from a plane but now it is. It just highlights how sometimes when you consider usability, you have to think about all the possible scenarios that your users will be in while interacting your application.

BTW, I’d love to hear from other people on potential error messages that might be scary in other contexts.

The screenshot above is from Anthony Rogers’ blog (UI designer for the tool), and the next one is from Chris Oliver’s blog, who successfully managed to hide away from most of the geek crowds at JavaOne.

The design of the tool is looking really nice and clean, the timeline reminds me a bit of the Adobe Premiere CS4 one. But unlike Premiere or Flash CS4, one interesting design choice is the lack of row headers to identify the different elements or categories for the rows in the timeline. This makes it look a bit cleaner and less cluttered, but it would be interesting to see if this doesn’t make it more difficult to track just what it is you are supposed to be controlling in that part of the timeline. Hard to tell without trying the tool of course (hint, hint, Sun … available for alpha/beta testing!).

I haven’t seen a single bit of code in any of the screenshots/demos so far. I wouldn’t be surprised that there was some script text area somewhere, or maybe the expectation is that for code you go to a tool like Netbeans?

Tor Norbye also provides some additional information about the tool, it will be available as a webstart application that will let you save data in the “cloud” (like Google Docs) or locally, as well as run the tool online/offline.

Chris calls it the JavaFX Design tool, others the JavaFX Authoring tool, for sure neither of these is the final name for the product but I’m still a bit surprised it doesn’t seem to have any sort of funky codename at this point.

You can watch some short videos of the tool in action here.

“The classpath is dead“ … that’s what Mark Reinhold (Principal Engineer @ Sun) said at a general session during JavaOne 2009. It’s the type of statement that should resonate with any of us who have been victims of classpath/jar hell. Mark announced this in the context of reviewing the new language features due to be released in JDK 7 (ETA 2010) or more specifically the new Java module system codenamed Jigsaw.

Module Systems and Jigsaw

Jigsaw is a low level implementation of a module system, which also includes some language and VM changes that are specified in JSR 294 (note that Jigsaw is being done outside of any JSR and is not a reference implementation of 294). Another implementation of a module system most Java developers are likely more familiar with is OSGi. But what is a module system and why do we need one?

Depencies on multiple versions (of module B in this example)

A module system enables modular programming, it allows developers to separate code into clearly defined modules that can specify what other modules they depend on and their versions, can be internally modified without breaking other modules that depend on it and can hide its own internals from external modules.

A module system can solve the classpath/jar hell problem by leveraging the previously mentioned features in order to allow an application to use the right versions of the set of libraries it requires. In the diagram shown here, we have an APP module that depends on the A, B and C modules. But module C also depends on B, however this dependency is to a different version of B than the one APP needs. A useful module system would then allow us to have 2 versions of the B module, with the compatible version and implementation visible to the appropriate modules (in this case APP and C).

Also, by clearly expressing module dependencies, we no longer have to look at random lib folders or hidden documentation when using a 3rd party library, just so we can guess what the corresponding jar files are needed to run it. With the system implemented by Jigsaw, we can simply introspect the module and let it tell us what those dependencies are. It takes the guesswork and the dark magic completely out of the equation.

But back to Mark’s presentation at the general session. The main reasons to introduce Jigsaw into JDK 7 are the following:

• Eliminate classpath complexity (classpath/jar hell problem already discussed).
• Increase performance. The VM download size can be made smaller, and startup time should improve because for small programs (say HelloWorld) unnecessary classes don’t have to be loaded at all. Mark showed how he could run HelloWorld by only using 2 modules listed by the new jmod command; jdk.base@7-ea and jdk.boot@7-ea.
• Enable native integration for installing modules.

Mark demonstrated that last point by showing a demo of him installing various JDK packages via the Synaptic Package Manager.

Installing Java modules via Synaptic Package Manager

Alex Buckley’s presentation

I attended Alex Buckley’s (Computational Theologist @ Sun) session on “Modularity in the Java Programming Language: JSR 294 and beyond”, which had a lot more details on the specific language changes to be implemented in order to support this new feature.

The most noticeable aspect of this is the introduction of module-info.java. This file goes at the top of your module filesystem, and is the class that specifies at compile and runtime the definition of the module. Here is an example, coming from Alex’s slides;

module org.planetjdk.aggregator {
          system jigsaw;
          requires module jdom;
          requires module tagsoup;
          requires module rome;
          requires module rome-fetcher;
          requires module joda-time;
          requires module java-xml;
          requires module java-base;
          class org.planetjdk.aggregator.Main;
 }

Our module is “org.planetjdk.aggregator” and uses the jigsaw module system. Depenencies are denoted by using requires and providing the module name, Alex calls this part of the module metadata the “logical classpath” of the module. You can also define the main class for the module which in this case is “org.planetjdk.aggregator.Main“.

You’ll also notice that the module name is quite long “org.planetjdk.aggregator”, while the list of required modules uses shorter names. This can be done by supplying a module alias. In the previous example, we could have added the line;

provides module aggregator;

This would then allow other modules to say “requires module aggregator” and successfully link to this module by this shorter form of the name.

Also, you can specify your module version and version dependencies in module-info.java. This updated example illustrates this mechanism;

module org.planetjdk.aggregator @ 1.0 {
          system jigsaw;
          requires module jdom @ 1.*;
          requires module tagsoup @ 1.2.*;
          requires module rome @ =1.0;
          requires module rome-fetcher @ =1.0;
          requires module joda-time @ [1.6,2.0);
          requires module java-xml @ 7.*;
          requires module java-base @ 7.*;
          class org.planetjdk.aggregator.Main;
}

Note also that you can only have one module-info.java per module, in only one location, so if you have a big source tree and you want to create multiple modules from it you will have to either separate your source into different trees or use some creative scripting to accomplish this at build time. I believe Mark mentioned they had to use some scripted solution for the jdk base as I believe it's one tree.

The rest of Alex's presentation focused on how to locate modules at compile and runtime by using the "modulepath", the use of the new module keyword and how it affects accessibility, and he gives a glimpse as to how they plan to support other module systems (for example, the version notation can be different when using other module systems).

This is all better explained in Alex's slides, so I encourage everyone to take a look at his presentation (link provided above).

The Modular Java Platform: Q&A

There were rumors in the meeting that the clown is a secret member of the Java Posse

Wednesday night, I attended a BOF like meeting hosted by Mark and Alex setup in order for the community to openly ask and voice any concerns over the work presented by them on modular Java. The setup was sort of a round table configuration (without the round table) in a very informal setting (btw it was hard for participants in the back to listen well, hopefully microphones are used next time). The first question was kind of funny, somebody asked Alex what a "Computational Theologist" does (the title makes it sound like the equivalent of a Thomas Aquinas for the nerd world).

After that, it seemed some people were very concerned about how to deploy modules, patch jars and other deployment issues. My impression was that a lot of people had a problem with the native installation part of the proposal. Mark answered that Java developers have gotten used to being in our own little jar world, separate from the OS integration issues of module and library management and that it was time for Java to integrate more with these systems. He has a point, do we really have to deploy log4j jars with all our products over and over instead of simply having a log4j installed in the system that all modules can refer to?

However, installation with native package systems is a big change. And it is also unclear what that is going to look like in Windows. It seemed like the Windows part of the equation has not been finalized, would Java 7 include some type of Java specific module registry or would it leverage something like .NET's Global Assembly Cache?

Somebody bought up the point that this new system was imposing more work on open source projects. That is, today you want to release your library as a jar, you know it's going to work everywhere. With Jigsaw, projects may have to deliver a large set of native module packages depending on all the platforms they want to deploy to. Many suggested to Mark and Alex that a cross platform package format was needed, but Mark acknowledged that Sun is not really working on that and they're just worrying mainly about specifying the module file structure and leaving the rest to the native package systems.

I noticed a few members from the OSGi community in attendance, I recognized Peter Kriens (member of the OSGi Alliance), Richard S. Hall (From Apache Felix, works for Sun in the Glassfish team) and BJ Hargrave (CTO of the OSGi Alliance, committer on Eclipse Equinox and IBM employee). Peter and Richard are both members of the expert group for JSR 294, so I was a bit surprised they weren't at all in "harmony" with Mark and Alex and the work they've done with Jigsaw. See, last time I saw discussions on this topic, JSR 277 was still active (it is on hold for now) and I was under the impression that Sun and OSGi had reached some type of "gentleman's agreement". That doesn't seem to be the case at all.

OSGi is a very mature technology and has more features than Jigsaw. However OSGi doesn't address the issue of native package installation, and you could argue that it would not be suitable to solve the issue of modularizing the JDK itself. I think on that last point, many people don't mind Jigsaw even on the OSGi side, the arguments come when you say Jigsaw could be used as an application level module system. Additionally OSGi still has some key features that are missing in Jigsaw; it allows more dynamic loading of modules (useful for plugins) and is backwards compatible (Jigsaw will only be supported from Java 7 and up).

Having said that, one thing I like more about Jigsaw is how it defines dependencies is the module-info.java file. It is a much better syntax than the error prone use of manifest files used in OSGi, where an extra space can break the whole thing for you. Adding keywords for module accessibility is also a very nice thing, and it seems the goal is to also let a modular system like OSGi take advantage of these features. Now how can these both systems inter-operate between each other in a single VM? I have no idea how that works ... yet.

In the end, the Q&A showed that there is a lot of controversy and confusion over this new feature. There was also a noticeable lack of questions during the meeting, with a few of the same people asking all the questions. I got the impression that the need and functionality of a module system in Java is not generally fully understood, so to me that means a lot more work needs to be done to explain just what is going on and why there is so much effort going into this area.

Some key questions I'd like to see clarified:

• A more technical and detailed explanation of why Jigsaw was chosen over OSGi.
• Will the JDK provide tools for wrapping modules in native packages?
• Is a cross platform package system completely out of the question?
• How would multiple modules systems work together in the same VM/application instance?
• What happens when an applet or javafx application requires core JDK modules that are not present in the current installation?
• Native library module integration issues (I sort of asked this in the Q&A). Where are native packages placed, and what happens when multiple modules include the same native libraries (say 2 modules have the same DLL embedded in them)?

This doesn't affect me, why should I care?

These changes will affect everybody, at the very least under the hood your core Java packages will be loaded in a more modularized fashion. For people who would like to run Java in other devices, you will notice that you have better ways to split up your Java distribution to only the parts that you need.

However, if you are interested in scaling your code the right way and modularizing it, you should start becoming familiar with what is going on in this space. For your applications, you'll still have the choice of using existing modular systems like OSGi or using the new facilities provided by Java 7. In the future, we should expect more details to come out as to how you can combine both (Jigsaw and OSGi). Others might prefer not to depend on an external Java project like OSGi and leverage the core support that will be provided for modules.

On the other hand, some people criticize that his is a repeat of the java.util.logging fiasco and say they can mostly ignore these changes. The jury is still out, but this is a very fundamental change in the language and platform and a very different scenario than choosing what logging package to include in the core JDK.

Oh and you might soon see new annoying interview or exam code questions trying to trip you up with gems like this one (from Alex's slides and this blog entry):

package module;
// BTW you should NEVER write code like this!!!
module class module {
        module module module = new
            module();
        module module() {}
}

Anyways, sorry for the longish blog post but hopefully this sheds some light into some of the discussions about this topic that took place at JavaOne. If you are interested in getting more in depth details about this topic, please take a look at some of the following links;

Java SE: Project Jigsaw: Modularizing JDK 7
Project Jigsaw (Mark's blog)
The Modular Java Platform (Mark's blog)
The massive, monolithic JDK (Mark's blog)
Packaging Java code (Mark's blog)
Project Jigsaw: Language changes for Modules
Project Jigsaw (Peter Kriens, his version of the "saga of Java modularity)
Project Jigsaw #2 (Peter Kriens, some criticisms of the proposed system)
Project Jigsaw #3 (Peter Kriens, Jigsaw != JSR 294)
Jigsaw - the death knell of JSR277?
Jigsaw vs OSGi?
A wrinkle with 'module' (Alex's blog)
Modularity in Java (Alex's presentation at DEVOXX 2008; covers module friendship, "virtual modules", multi-module packages, type observability and other topics not covered in the JavaOne slides I linked to in this article)

Update. Some additional links that have come to my attention after publishing this blog post;

Jigsaw Feedback Roundup (Dalibor Topic)
Java Posse #259 - Jigsaw and JSR 294 Interview (Java Posse podcast interview with Mark Reinhold and Alex Buckley)

During this morning’s JavaOne general session, the “James Gosling’s Toy Show”, Tor Norbye gave another preview of the “JavaFX Authoring Tool” (TODO: Needs a cool codename!!!).

In 2007 when I blogged about the original JavaFX announcement at that year’s JavaOne, one of my first questions was about the tooling. At first we basically just had JFXPad to play around, then came more integration with Netbeans. However, these are not designer tools, and a RIA application needs more access points of people who are not software developers. This was partially answered with the JavaFX plugins for tools like Adobe Photoshop and Illustrator, but what was really missing was a visual place to bring content together interactively and created animated content.

So now we see glimpses of the JavaFX authoring environment that Sun plans to release. The tool seems to be in the early stages of development and it is unclear when it will be released. However, some of the features look very compeling and familiar. Like any of the versions of the Adobe Flash tools, it features a timeline with the ability to edit key frames and create animated transitions. It also allows you to drag and drop media and JFX components (including the new 1.2 controls) to compose your app.

The coolest feature is that the tool aims to deliver on the “multiple screens” theme of JFX, you can easily output your project for a JFX desktop application, mobile and the plan is to have output for TV applications.

The following videos demonstrate the basics of the tools …

And this next video features the visual binding feature that allows you to graphically bind properties between target and source objects, with inline display of the properties.

The tool looks nice, but it’s too early to compare it to any of the equivalent Adobe or Microsoft tools. To me this type of tool is key to adoption, so I wish the team the best of luck and that they hopefully find an effective way to get feedback via previews just do sanity checks on the tool (hint, hint, I wouldn’t mind preview access

One final note, I think there’s a need for a JFXMattise like tool. I don’t know if this tool is it, I don’t think so. Basically, maybe a subset of this tool, embedded in Netbeans that allows developer type people to visually compose their JFX applications, with an emphasis on visual UI control and layout composition. As it stands, I think there’s a big gap there even if this tool is released.

Update 1: I added another video showing how you can edit “multiple screens”. That is, tweak your JFX application in other devices with different resolutions out of a main project. In this case, you can have this full resolution application with several smaller windows targeted for mobile devices. The cool thing is that you can tweak one of the target devices to say have less buttons so it can still be tailored for other platforms.

Also Tor has posted a blog entry about the tool (which is the current project he’s working on).

Update 2: New screenshots of the JavaFX Design Tool

I’ve heard this question asked quite a few times around the hallways of the Moscone Center this week.

There are no guarantees or definite answers, even Ellison didn’t really provide many details when asked (he probably can’t) but I think the answer is a definite no.

It is well known that Java is a big part of why Oracle is buying Sun. Ellison’s address to the attendees last Tuesday served to reassure the Java community that Oracle is not here to tear Java apart piece by piece. Quite the contrary, he seems willing to continue to invest in the platform.

But let’s remember that buying Java means more than making Sun employees your employees, or buying widgets. What Oracle is also getting in the deal is the Java community … no small incentive for a technology company. Removing JavaOne from the landscape wouldn’t make sense for Oracle since that could threaten goodwill and slowly erode the community and enthusiasm for the Java platform.

From the many college students attending this year, learning about Java for the first time (I’ve met 2 that say their Universities only teach C/C++) to the sometimes heated discussions about technologies and new language features (like the Modularity Q&A, oh boy, stay tuned for my blog post on that one!). A lot of these interactions are hard to do effectively without an event like this, where people can freely and dynamically regroup and discuss their ideas about the Java platform.

So no, I don’t think Oracle will “deprecate” JavaOne. Expect it to change of course, but don’t expect it to disappear and be merged with OpenWorld anytime soon.

BTW, this is likely the last JavaOne conference Scott McNealy will ever attend and he acknowledged that during his keynote. In a very emotional moment, McNealy said his last goodbye to the community at the conference … and from what I could tell even choked up a bit.

When he was done presenting, he was greeted with a standing ovation from the audience. Afterward, he hung around and took pictures with many of the participants.

I thought this was a nice moment, and I think the gesture from the audience was very kind. Whatever you say about McNealy, nobody can deny his passion and the trust he always put on his team, especially to his engineers.

From left to right; Dan Salt, Scott McNealy, some guys with his eyse closed and me

Visiting the JavaOne pavillion yesterday at CommunityOne, one thing that stood out was the absence of Oracle. This year there is no Oracle booth, which is very unusual, and a lot of people are wondering what is going on with the Sun/Oracle merger which nobody from Sun is really talking about.

My guess is that due to SEC regulations they’re not allowed to talk about it. But I’m not an expert in that area so I’m wondering if anybody knows what the rules are. However, Larry Ellison just walked in front of us a few minutes ago so we might yet see an official announcement about Sun/Oracle this morning. My guess is we wouldn’t hear about it, but then why would Ellison be here if he’s not going to speak at the podium?

(Sorry for the crappy picture, but there was no light, no flash and he zoomed by … most people in the audience don’t know he’s here … yet)

Update: As soon as I hit “publish” McNeilly stars talking about Sun/Oracle. Joking about rumors of course.

Update 2: “Don’t expect a lot of changes, just increased investment”, Ellison tries to reasure developers at this morning’s keynote. Ellison mentioned how Oracle pretty much uses Java everywhere for their products and he mentioned JavaFX a lot, plus interest in OpenOffice and mobile. For those wondering if Oracle was interested in the client side, I think Ellison has pretty much answered that very clearly.

JavaOne officially starts tomorrow but today Sun has kicked off CommunityOne. Which is a more open source focused and free conference that precedes the bigger event.

The main theme this year is cloud computing. The presentation today has been about showing several vendor solutions in the areas of virtualization and large scale application deployment that is very easy to use (and graphical). To be completely honest, I think “cloud computing” is a big buzzword approaching marketroid levels, but there is some interesting technology here. I’ll be attending a few cloud computing sessions to see if I become one of the converted.

Currently, we’re listening to some of the folks from OpenSolaris and JavaFX in a setup that seems like a nerd version of David Letterman from an alternate reality.

BTW we got a small announcement that JavaFX is now officially released for OpenSolaris. Although I’m not sure there’s a large community of OpenSolaris users looking forward to that

Maybe I’m being a bit unfair, but the way the press is hyping it as a potential “Google/Wikipedia Killer” really doesn’t do it any favors. The site itself doesn’t say it’s a search engine, it describes itself as a “computational knowledge engine”. You’re supposed to enter a question or calculation and it will give you a result in the areas of mathematics, engineering, physics, places & geography, etc.

So first test is, can WolframAlpha tell us what a “computational knowledge engine” is?

Question: What is a computational knowledge engine?

WolframAlpha: Wolfram|Alpha isn’t sure what to do with  your input.
Google: Top link is a blog entry titled “So what exactly IS a computational knowledge engine?”

Hum … not a good start. Also, Google’s second link is a link to WolframAlpha itself. Well, it says Wolfram Alpha is also good for business queries. Let’s find out information about a company.

Question: Who is the CEO of Apple?

WolframAlpha: Wolfram “assumes” I’m talking about CNOOC Limited, whose stock symbol is CEO. So the result is some financial information about CNOOC and Apple. Not what I was looking for.
Google: First link is Apple’s bio page on Steve Jobs.

Google wins again. Let’s look at historical figures.

Question: Who is Martin Luther King?

WolframAlpha: First accurate answer we get! WolframAlpha provides us minimal information about Martin Luther King Jr. It provides his full name, dates of birth and death and even the place of death. We also get a nifty time line, showing that last piece of information in graphical form (Which would only be useful if we were comparing events). Note that it also shows a “related links” which links to the Wikipedia entry on Martin Luther King Jr. which actually has a lot more information of course.
Google: First link is the Wikipedia entry that WolframAlpha also linked to. However the next link is a biography from the Nobel prize website and we also get a couple of YouTube links on the “I have a dream speech” and other moments.

This is kind of a tie I guess. WolframAlpha gives you minimal information, but it’s nicely summarized yet horribly incomplete. However, you get the Wikipedia entry to get more background information. Google gives you more results, but doesn’t give you a concise summary right there on the results about Martin Luther King Jr. like Wolfram does.

Let’s ask mathematical questions, this is where WolframAlpha is supposed to excel.

Question: What is an inductive proof?

WolframAlpha: Wolfram|Alpha isn’t sure what to do with your input.
Google:  Results are really good; Mathematical induction – Wikipedia, the free encyclopedia, Induction Proofs: Introduction, Mathematical Induction, etc.

Question: sin(1) + cos(1)

WolframAlpha: We get lots of results, plots, alternate forms, roots and the decimal approximation to a ridiculous level of decimal places 0.4546487134128…..
Google: sin(1) * cos(1) = 0.454648713

Question: x + 250 = 15

WolframAlpha: We get “x = -235″ and get a plot for the equation.
Google: Doesn’t understand simple algebra equations and returns garbage.

And we can go on. Clearly you can see WolframAlpha is not really a search engine at all. You won’t find news, websites or most of your search related queries here. When it comes to basic definitions and parsing common language questions; WolframAlpha seems pretty dumb so far. Even in the area of mathematics, it won’t give you definitions for some common concepts. I also tried some Computer Science concepts and it had trouble too.

This “computational engine” is more apt for actual computational tasks. You want to solve some mathematical problem (say determine if a number is a prime number, equations, trigonometry, etc) or have it expressed in different ways (alternate forms and representations) and this engine will help a lot. But for your more common task for searching for general information and items with in depth explanation of concepts and places, you are still better off using Google in conjunction with Wikipedia.

Hopefully people will realize this and tone down the hype, Google and Wikipedia are not threatened by this engine at all. Although I do think that Wolfram Alpha might cause Google to invest a bit more in it’s mathematical calculation engine which currently pretty much functions as a very simple web enabled pocket calculator.

One last note: For some reason Wolfram Alpha returns results as images … even simple textual information. I don’t know why they do this at all. For example in my search for Martin Luther King, if I wanted to copy his name or date of birth, you get a little annoying dialog with the actual text so you can copy it. You can’t use the normal method of highlighting the information you want right there on the page. Very annoying and I hope they reconsider this dreadful “feature”.

At one point it was Apple, then IBM was supposed to be it more than a couple of times, well the buyer of Sun ends up being Oracle and I think this is a good thing.

First of all (and related to that panel from Watchmen), I was getting a little anxious about all this merger talk and wished it was done with. It’s difficult for a company to be under merger talks for too long, and as a user of a lot of Sun technologies it makes you nervous. So I’m glad this seems to be over with.

Anyways, I think ithis is better than the IBM-Sun (BlueSun) merger because it just didn’t make much sense for IBM to buy Sun. They overlap too much on hardware and software, and I was afraid IBM was just going to buy it to finally kill off a hardware competitor and just take ownership of Java. With Oracle, you still have IBM as a strong Java player and Sun actually brings a lot of new things to Oracle.

Yes, there are overlaps, but there’s a bigger chance for projects like Netbeans to survive under this environment than in a company with IBM which would rather keep putting money on Eclipse.

What I wonder about is these products:

JavaFX - Does Oracle really have the stomach to compete in the client space? I’m hoping they have the guts to keep at it and not settle only on the server side. Client side Java is still important, and makes sense when you want to have very well integrated tools that go from end to end. As for mobile, who knows, maybe Oracle wants to expand.

Glassfish - Can Glassfish survive in a company that uses WebLogic. I think so, at least initially or for the short term. Glassfish can still be used as the “JEE” reference implementation, so there is a chance Glassfish can still continue being a supported project.

MySQL - I’m not really sure Oracle wil want to keep spending money on this for obvious reasons. But who knows. Anyways, MySQL is open source so it can’t really be killed in a sense.

So I’m glad the speculation is over, good luck to all the Sun employees during this transition. This year should prove to be a very interesting and surreal JavaOne!

Hey kids, don’t forget, when you open up a CRT display you can electrocute yourself if you don’t know what you are doing. So please don’t do what Bjork just did in the video above, specially if all you are doing is showing us how the electronics inside are like a “little model city … with houses and streets … and this elevator …”.

Do pay attention to her warning, “don’t let poets lie to you”. They don’t know anything about electronics!