The recent release of Google Chrome Beta for Windows has re-stirred the good old browser wars. Chrome is based on WebKit, but uses the V8 Javascript Engine Currently Chrome is a Windows only browser, so it is not possible for me to benchmark the browser first hand, but the claims have been that it is faster than both Firefox and WebKit on Windows.

Those are pretty bold claims, especially since the folks over at WebKit just released the SquirrelFish Extreme Javascript engine. Based on my initial personal non-scientific benchmarks, it looks fast! Almost 2x’s as fast as the previous SquirrelFish implementation. See the results below.

After using WebKit for the past two months it is clear to me, WebKit is the best browser for me on Mac. There is one small issue with using WebKit, namely, since you are running a nightly build, you need download and update the binary quite often, and some of the time, the daily build is not the stablest. Again, this is just a minor price to pay in order to take advantage of the latest and greatest build. It is nothing specific to WebKit, it applies to any beta software.

Latest Results

• WebKit (SquirrelFish Extreme) Results URL
• WebKit (SquirrelFish) Results URL

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

TEST                   COMPARISON         FROM                 TO
                                         (SquirrelFish)    (SquirrelFish Extreme)
=============================================================================

** TOTAL **:           1.86x as fast     1918.6ms +/- 0.9%   1032.6ms +/- 1.4%    

=============================================================================

  3d:                  1.59x as fast      260.6ms +/- 2.9%    164.2ms +/- 4.6%
    cube:              1.53x as fast       84.2ms +/- 5.9%     55.2ms +/- 4.3%
    morph:             1.36x as fast       82.8ms +/- 2.0%     61.0ms +/- 4.8%
    raytrace:          1.95x as fast       93.6ms +/- 4.3%     48.0ms +/- 11.1%    

  access:              2.49x as fast      280.2ms +/- 4.1%    112.4ms +/- 6.0%
    binary-trees:      1.64x as fast       36.0ms +/- 15.1%     22.0ms +/- 22.2%
    fannkuch:          4.76x as fast       88.6ms +/- 3.8%     18.6ms +/- 9.0%
    nbody:             2.03x as fast      124.8ms +/- 7.3%     61.6ms +/- 2.3%    

  bitops:              2.31x as fast      188.8ms +/- 4.5%     81.8ms +/- 9.9%
    3bit-bits-in-byte: 1.96x as fast       26.6ms +/- 13.5%     13.6ms +/- 24.7%
    bits-in-byte:      1.96x as fast       32.6ms +/- 8.8%     16.6ms +/- 22.2%
    bitwise-and:       1.77x as fast       54.8ms +/- 4.4%     31.0ms +/- 15.5%
    nsieve-bits:       3.63x as fast       74.8ms +/- 14.5%     20.6ms +/- 15.7%    

  controlflow:         1.35x as fast       27.0ms +/- 22.6%     20.0ms +/- 19.2%
    recursive:         1.35x as fast       27.0ms +/- 22.6%     20.0ms +/- 19.2%    

  crypto:              1.98x as fast      129.6ms +/- 7.7%     65.4ms +/- 6.7%
    aes:               2.51x as fast       45.6ms +/- 14.8%     18.2ms +/- 24.3%
    md5:               1.74x as fast       39.6ms +/- 14.8%     22.8ms +/- 6.0%
    sha1:              1.82x as fast       44.4ms +/- 27.6%     24.4ms +/- 6.8%    

  date:                1.78x as fast      172.6ms +/- 2.6%     96.8ms +/- 2.9%
    format-tofte:      2.42x as fast      105.2ms +/- 3.5%     43.4ms +/- 3.3%
    format-xparb:      1.26x as fast       67.4ms +/- 5.6%     53.4ms +/- 5.8%    

  math:                1.50x as fast      206.6ms +/- 4.1%    138.0ms +/- 1.7%
    cordic:            1.59x as fast       67.6ms +/- 5.9%     42.4ms +/- 4.4%
    partial-sums:      1.45x as fast       97.8ms +/- 3.7%     67.6ms +/- 3.6%
    spectral-norm:     1.47x as fast       41.2ms +/- 8.6%     28.0ms +/- 6.3%    

  regexp:              4.27x as fast      198.8ms +/- 1.6%     46.6ms +/- 6.4%
    dna:               4.27x as fast      198.8ms +/- 1.6%     46.6ms +/- 6.4%    

  string:              1.48x as fast      454.4ms +/- 1.6%    307.4ms +/- 2.4%
    base64:            2.56x as fast       64.6ms +/- 4.0%     25.2ms +/- 10.7%
    fasta:             1.43x as fast       85.4ms +/- 3.4%     59.6ms +/- 5.6%
    tagcloud:          1.14x as fast      112.0ms +/- 7.2%     98.2ms +/- 2.7%
    unpack-code:       1.75x as fast      118.6ms +/- 3.4%     67.8ms +/- 3.0%
    validate-input:    1.30x as fast       73.8ms +/- 4.0%     56.6ms +/- 9.5%

It took all of 15 minutes, and that included upgrading TinyMCE to version 3.1 as well. WordPress is one of my favorite open source packages.

Recently they have out done even them selves with the introduction of WordPress for iPhone. After using it for a while it is clear that it is a really nice app! If you are lucky enough to own an iPhone and happen to have a WordPress blog as well, then it is a no brainer. You need to download and install it right away.

After using WebKit for the past few days it is evident to me that it performs better than Firefox on my Macs. The question is how much better? Is it possible to quantify the performance difference? After searching around found this JavaScript benchmarking site.

Details

The data was obtained by running the SunSpider JavaScript Benchmark.

The benchmark was run on a 2.4GHz Core 2 Duo MacBook equipped with 4 gigs of memory running Leopard (10.5.3).

To generate the below results for your self, follow the WebKit Results Link and then paste the Firefox results link in to the box that says “To compare to another run…”

• WebKit Results URL 
• Firefox Results URL

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

TEST                   COMPARISON         FROM (Firefox)  TO (WebKit Nightly)

=============================================================================

** TOTAL **:           1.57x as fast     3002.8ms +/- 1.3%   1918.6ms +/- 0.9%

=============================================================================

  3d:                  1.47x as fast      383.8ms +/- 7.3%    260.6ms +/- 2.9%
    cube:              1.61x as fast      135.2ms +/- 2.9%     84.2ms +/- 5.9%
    morph:             1.53x as fast      126.4ms +/- 20.3%     82.8ms +/- 2.0%
    raytrace:          1.31x as fast      122.2ms +/- 4.7%     93.6ms +/- 4.3%

  access:              1.49x as fast      418.2ms +/- 3.4%    280.2ms +/- 4.1%
    binary-trees:      1.38x as fast       49.8ms +/- 3.7%     36.0ms +/- 15.1%
    fannkuch:          1.83x as fast      162.4ms +/- 4.5%     88.6ms +/- 3.8%
    nbody:             1.19x as fast      149.0ms +/- 7.6%    124.8ms +/- 7.3%
    nsieve:            1.85x as fast       57.0ms +/- 9.5%     30.8ms +/- 7.2%

  bitops:              1.57x as fast      296.6ms +/- 3.6%    188.8ms +/- 4.5%
    3bit-bits-in-byte: 1.84x as fast       49.0ms +/- 10.3%     26.6ms +/- 13.5%
    bits-in-byte:      2.34x as fast       76.2ms +/- 3.1%     32.6ms +/- 8.8%
    bitwise-and:       1.43x as fast       78.2ms +/- 5.9%     54.8ms +/- 4.4%
    nsieve-bits:       1.25x as fast       93.2ms +/- 7.7%     74.8ms +/- 14.5%

  controlflow:         1.46x as fast       39.4ms +/- 6.9%     27.0ms +/- 22.6%
    recursive:         1.46x as fast       39.4ms +/- 6.9%     27.0ms +/- 22.6%

  crypto:              1.44x as fast      186.8ms +/- 3.7%    129.6ms +/- 7.7%
    aes:               1.59x as fast       72.4ms +/- 4.9%     45.6ms +/- 14.8%
    md5:               1.45x as fast       57.6ms +/- 7.6%     39.6ms +/- 14.8%
    sha1:              1.28x as fast       56.8ms +/- 9.3%     44.4ms +/- 27.6%    

  date:                2.12x as fast      365.8ms +/- 2.1%    172.6ms +/- 2.6%
    format-tofte:      2.01x as fast      211.8ms +/- 1.1%    105.2ms +/- 3.5%
    format-xparb:      2.28x as fast      154.0ms +/- 4.5%     67.4ms +/- 5.6%    

  math:                1.51x as fast      312.6ms +/- 4.9%    206.6ms +/- 4.1%
    cordic:            1.79x as fast      121.2ms +/- 2.9%     67.6ms +/- 5.9%
    partial-sums:      1.35x as fast      132.2ms +/- 9.7%     97.8ms +/- 3.7%
    spectral-norm:     1.44x as fast       59.2ms +/- 8.3%     41.2ms +/- 8.6%    

  regexp:              1.33x as fast      265.0ms +/- 0.5%    198.8ms +/- 1.6%
    dna:               1.33x as fast      265.0ms +/- 0.5%    198.8ms +/- 1.6%    

  string:              1.62x as fast      734.6ms +/- 0.7%    454.4ms +/- 1.6%
    base64:            1.33x as fast       85.8ms +/- 1.9%     64.6ms +/- 4.0%
    fasta:             2.25x as fast      192.2ms +/- 2.3%     85.4ms +/- 3.4%
    tagcloud:          1.38x as fast      154.2ms +/- 1.4%    112.0ms +/- 7.2%
    unpack-code:       1.67x as fast      197.8ms +/- 0.5%    118.6ms +/- 3.4%
    validate-input:    1.42x as fast      104.6ms +/- 1.4%     73.8ms +/- 4.0%

As you can see from the benchmark results, WebKit performs ~1.57x’s faster. The results are pretty much in line with my browsing experience. Please keep in mind these results are very specific to the conditions of my network, my computer, and the current utilization of the web server. Your results may vary.

Disclaimer

Please keep in mind benchmarks are benchmarks, and they are nothing more than numbers. This benchmark was not chosen because it favors WebKit in any way. Several sites use it to compare not only WebKit, but other browsers on other operating systems as well. Example here.

FYI

Webkit comes in ~1.68x’s faster than Safari 3.1.1. Safari 4 should be comparable to WebKit, since Safari 4 is based on the same code base as the current WebKit build which is based on the SquirrelFish JavaScript engine.

Just changed my default browser from Firefox to Webkit on Leopard (OS X 10.5.3). The main reason was because of the announcement of WebKits migration to the SquirrelFish Javascript interpreter. They claim that it is 1.6x’s faster than the previous WebKit interpreter and if its true, that is pretty good considering most of my daily work flow is based around web based applications.

Initial thoughts

It has only been a few hours since the switch, but I must say I am quite impressed with the performance especially on sites like GMail, Google Reader, and the TinyMCE editor for my blog. TinyMCE is not only faster, but now its “true” functionality is exposed as well. There are a few features available that were not available when using Firefox. The speed improvements alone are not really enough to keep my interest for long because of the other features WebKit lacks over Firefox. If there was a way to close the functionality gap, then we may have our selves a new default browser.

WebKit’s “Shortcomings” (Compared to Firefox + Favorite Plugins)

1. No new tab button
2. No Google suggest built in to the search box
3. No way to configure links to open in new tabs rather than new windows
4. No AdBlock plus (plugin)
5. No Google Bookmarks button (plugin)

Initial Solutions to the “Shortcomings”

1. This application will add a “New Tab” button on WebKit for you. If you decide to install it, make sure you back up your Safari directory prior to running the installer, as recommended by the author.
2. Inquisitor 3 will provide you google suggest like functionality in your search box. It is quite customizable, thus you can configure it use different search engines, display keyword results or web page results, among many other customizations.
3. This awesome tip shows you how to tell WebKit to open all links in new tabs instead of new windows.

4. Safari AdBlock is a drop in replacement for the Firefox plugin Adblck Plus. Set it, and forget it. Very easy to use. Haven’t really tested it yet with too many sites, but from the few sites it was tested with, the results look good.

   • Update: Switched to SafariBlock because Safari AdBlock was letting too many adds slip through, especially Flash ones.
   • Update Two: Switched to GlimmerBlock because SafariBlock was not really working well with Safari 4.

5. Still working on it. Any Suggestions would be greatly appreciated. If nothing shows up, will start working on a new browser plug in to handle it. 

   • Update: Found a plugin called ”Goggles” that provides access to Google Bookmarks.

6. Update: If you want the tab bar to always display even with one active tab use this great tip.

Conclusion

There you have it, in a little less than two hours, default WebKit was transformed in to a Firefox 3 feature compatible browser. Look for a post in a few days to give my updated thoughts on Webkit after using it for a while.

How many times have you written the following code:

1
2
3
4
5
6
7

void someMethod() throws X1,X2 {
  try { /* Something that can throw X1,X2 */ }
  catch (Throwable e) {
    logger.log(e);
    throw e; // Error: Unreported exception Throwable
 }
}

Need a way to express we are simply re-throwing the Exception that was caught.

The Proposal to add the safe re-throw to the language is as follows:

1
2
3
4
5
6
7

void m() throws X1,X2 {
   try { /* Something that can throw X1,X2 */ }
   catch (final Throwable e) {
      logger.log(e);
      throw e; // Compiles OK; can throw X1,X2
   }
}

Again, lets hope it makes its way in to Java 7.

How many times have you written code where you have something along the lines of:

1
2
3
4
5

try { do something interesting ... }
    catch (X1 e1) { close(); }
    catch (X2 e2) { close(); }
    catch (X3 e3) { cleanup();
}

It is cumbersome to have to catch X1 and X2 separately even though they perform the same action if an Exception is raised. Wouldn’t it be nice if there was a way to catch both X1 and X2 with one single catch block?

Enter the Java 7 proposal for Multi-Catch statements. If/when this proposal makes it in to the language, it would eliminate the need to have a catch statement for each Exception. It facilities a mechanism to catch multiple Exceptions, and then perform the same action on them eliminating the need to have one catch per Exception thrown.

1
2
3

try { do something interesting ... }
   catch (X1, X2 e1) { close(); }
   catch (X3 e ) { cleanup(); }

Now isn’t this code much cleaner? Let’s hope it makes it in to the next version of Java.

The purpose of this post is to give you a “high” level overview of Amazon’s EC2 (Elastic Compute Cloud), and how you can benefit from it.  Amazon defines the EC2 as

A web service that provides resizable compute capacity in the cloud. It is designed to make web-scale computing easier for developers.

From a high level, EC2 is nothing more than a huge server farm. If you are an end user who needs computing resources they can allocate “servers” to you. Only, when you get a “server” allocated to you, it is not a real physical server. It is a virtual server which is part of a huge farm of commodity based machines. The concept is very similar to that of VMWare (or any product that provides virtualization), except they do not use an off the shelf product, they have their own notion of virtualization which relies on their proprietary AMI’s (Amazon Machine Images). The coolest feature is it is quite inexpensive. It costs somewhere around $70 a month to maintain “small” server 24/7 for one month. The actual rate is .10/hr of up time. A “small” server by Amazon’s standards is equivalent to a box equipped with “1.7 GB of memory, 1 EC2 Compute Unit (1 virtual core with 1 EC2 Compute Unit), 160 GB of instance storage, 32-bit platform”.

If your needs require a more powerful box, you can get spring for their most powerful configuration. They refer to it as “Large” box, and it is equivalent to box equipped with “15 GB of memory, 8 EC2 Compute Units (4 virtual cores with 2 EC2 Compute Units each), 1690 GB of instance storage, 64-bit platform” This will set you back ~$575/month for 24/7 up time. The actual rate of this configuration is $.80/hr.

There is an additional charge that one would need to consider, namely, bandwidth consumed, both uploads and downloads (unless its to or from Amazon’s S3 service, in this case there is no charge). It is based on the amount and the location of each upload or download.

As you can see, Amazon’s EC2 is a very cost effective expandable server infrastructure. The next post will cover the important technical features of EC2 and how you can leverage them on your current project.

The purpose of this post is to wrap up my thoughts on this past Java One Conference. There are both positive and not so positive thoughts in my mind right now about the conference. Rather than merely stating this fact, let me describe the details to you.

I know it sounds like a dead horse at this point in time, but for the folks that were not present at the Conference,

Lets me begin by listing some of the the positive ones: (Not in any specific order)

• The Java Posse BOF:This was by far the most fun session for me. Forget about the fact that Atlassian brought beer for us to this session. It was like a big Geek get together where we were all there for the same purpose. To chill and discuss the happenings in the Java world.
• TextMate Rules the Mac:Every presenter showing any sort of code sample used TextMate.  I have started using it since, and I must say it is quite impressive.
• Scala has great potential to be the next preferred language of the JVM:Scala is not only totally interesting to me, but it is quite powerful as well.  I especially like the concurrency and Exception handling model built in to Scala.  I had a chance to go to the Java One book store and thumb through the new Scala book that is being released some time in July.  It is definitely worth a look once it comes out.

• Groovy is my new favorite scripting language: After attending numerous sessions on Groovy at Java One and local sessions at the NY JUG, I am convinced that Groovy is the way for me to “migrate” my thinking from one of Static to one of dynamic.  I have already started reading two really interesting books on Groovy. 

  • Groovy Recipes: Greasing the Wheels of Java
  • Programming Groovy: Dynamic Productivity for the Java Developer

• Grails is the best way to do RAD on the Java Stack:There is NO faster way to crank out CRUD leveraging Spring/Hibernate/AJax.

• Lots of cool people in attendance:It is great to mingle and hang out with so many Java enthusiasts.  Whether on a line waiting to get in to a session, or having one of the pretty decent boxed lunches, there was always a good conversation to be had. 
• The Groovy/Grails/NFJS meet up at the W Hotel on Monday night was great:Let me start off by saying Ted Neward rocks. Looking forward to the tour coming to NJ, will most definitely be in attendance.
• The Script Bowl Session:Very cool and interesting session. It took the format of American Idol. There was representatives from all of the major scripting languages up on the podium along with a moderator, and three judges. The judges didn’t have have any say on the matter. It was up to us (the audience) to decide the winner by texting our ratings to a number they set up ahead of time for each of the three rounds. The language with the best ratings would be declared the winner.
• OpenSolaris and ZFS are cool:The demo with the ZFS team smashing one of the hard drives with a huge hammer, and then demonstrating the RAID is still fine. But, they didn’t stop there, then they used a drill to kill another drive, and the RAID was still fine. Then they added two brand new drives to the RAID, and demonstrated how the RAID was rebuilding. The demo was quite impressive, and it left a lasting impression on me. I may have to migrate some of my Ubuntu boxes over to OpenSolaris. That is, if I have time, and it runs well on my x86 hardware.

And now some of the “not so positive” (disappointing) ones: (Again, no specific order)

• Too Many People - Lines, lines, lines everywhere:The lines at Java One this year were a bit out of control, and I don’t know who we can blame. Was it the Moscone security staff? It is not clear to me right now. The lines heading in and out of the popular sessions felt more like a rush hour train pulling in to NY’s Penn Station. At some points during the show it was hard to even pass in some places. I.e., in space out side of the Pavilion area, where they had the movies playing along with some live simulcasts, there were so many people standing around watching the broadcast, there was NO room to even walk making it difficult getting from one session to the next
• The materials presented in some of the sessions was more “marketing” then technical:It was always my understanding that you go to these type of conferences to get a “technical edge”. It felt like most of the presenters were not presenting very technical material during the session. It was more like, my framework is the best because… or this framework is better than that framework… To get to the real details, we need to go to their websites, their blogs, or read the books.
  Don’t get me wrong, all of the sessions were not like this, but it felt like quite a few of them were. See above for the sessions that were not like this.
• Internet access was unreliable at best:You would expect a conference hosted by Sun Microsystems where there tag line is “The network is the computer”, to provide more stable internet access for the attendees.

Some thoughts after this years Java One

• NFJS better for me:It is smaller, closer, and more technical.  Last one I attended in 03 in Philly was a total blast, and I look forward to the same experience when it comes to NJ.
• Going to focus on three languages moving forward:Java, Groovy, and Scala.
• Looks like multiple languages are the future of the Java Platform:Don’t know which one, but it is pretty clear that most people want an updated programming model for the Java Platform.
• Next Task:Create a library of all of the idioms in Effective Java in all of the three languages. I.e., Implement code each idiom in each of the three languages. Then use JUnit to test each class. Proving that you can call each language construct from Java. Also going to put metrics around each method call to allow me to create a list of benchmarks on each of the languages.

That’s all for now.

In case you haven’t noticed, this site is finally looking a bit more, dare I say, “professional”. All it took was a little bit of time, and some minor *nix commands. Since this site is based on the latest version of Wordpress (2.5.1) , it provides a lot of usefulness out of the box when dealing with the overall layout of the site, the layout of the widgets, and ease of plugin configuration. Wordpress is a brilliant piece of software.

The first and most obvious thing to tackle first is the look and feel of the site. The original theme that was used wasn’t really cutting it any more. A cleaner and more professional looking theme needed to be found. After quite a bit of searching through the theme repositories, found a theme called spotlight, which definitely meets the requirements of looking professional and clean.

The next improvements were made with the addition of some nice plugins. These plugins are:

• Configurable Tag Cloud - Cool plugin/widget that allows you to really customize the look and feel of the Tag Cloud. Tons better than the default Tag Cloud widget that comes with Wordpress.
• MyTwitter - Nice plugin that displays your current Twitter updates, and allows you to post updates as well via the configuration page.
• SyntaxHighlighter
  • A plugin that allows you to post code for nearly every programming language, and renders it in a very clean and usable fashion. Originally noticed the nice looking code on DZone.

These are the few plugins installed on this site. There are tons more out there. If you have any personal favorites, please let me know.

Well folks, another year, another Java One has passed. This conference has definitely got me thinking about a lot of things, especially the future of Java “The programming language”. You must be thinking, why in the world did I add that little blurb about “The programming language”, I mean, Java is nothing but a programming language right?

Wrong! There is a little thing called the JVM (Java Virtual Machine) that most of take for granted each and every day, when we open our IDE’s, start up our Application Servers, run our debuggers, etc…

Did you know that over 200 programming languages have been ported to run atop the JVM? All this talk about Java showing its age, and being out dated doesn’t necessarily mean that Java is going away. The language may go away, and when I say go away, I don’t mean go away, I mean maybe not be the top choice of language for writing future applications on top of the JVM. Java will never go away, just like Cobol is still around. There are enough core business systems written in Java/J2EE to last a life time. Just ask any Cobol programmer, after 30 years, they still have jobs available to them.

You must be thinking how can I compare Java to Cobol! Well, let me pose this question to you, namely, if a recruiter calls you up today describing an excellent opportunity working with J2EE/Struts 1 application. What would you think? J2EE/Struts 1? To me, that is “legacy” code, and it is nothing that I would like to work with now a days.

Dare I say it? Parts of the Java ecosystem are starting to look like Cobol? This is not a new concept at all. It all started many years ago. I would say some of the first people to publicize it was people such as Rod Johnson (Creator of The Spring Framework and CEO of Spring Source) and Bruce Tate (Author of Bitter Java, Better Faster Lighter Java, and Beyond Java). I would have to say that Bruce Tate said it best in his book Beyond Java. Keep in mind that book was authored many years ago. Thus, what I am saying is nothing new at all, it is just a concept that was thought of many years ago finally coming in to fruition.

Where is the proof? The proof is in the pudding (The JVM pudding). At Java One this year, it felt like it shouldn’t really be called Java One anymore, but maybe JVM One. It was interesting to see all of the slides at Java One this year said “The Java Programming Language” instead of just Java. Each session I attended the Presenter found it interesting how their slides were modified making this distinction. If you look beyond the slides, you start to see something interesting, namely, the fact that over half of the sessions offered had nothing to do with Java the language. Sessions like, “The Scripting Bowl”, which was a competition putting some of the leading scripting languages against one another. (I will go in to more details in a separate post, it was quite an interesting session), “Grails In The Enterprise”, “JRuby on Rails”, “Functional Programming with Scala”, to name a few. There were many more.

After a weekend of recovering from information overload, I think I have finally drawn a conclusion, namely, Sun has realized that Java the programming language has lost steam with all of the “Cool” folks. There are tons of efforts going on to try to make Java more appealing again like adding Closures to it. Right now, that effort is confused at best. No one has a clear and direct answer to how/if they should be added. It is of the opinion of some folks, that we should stabilize Java as it is, and create a new and improved Java 3.0.

The main point to focus on here is the distinction Sun is making between Java the language and Java the Platform, and the reasoning behind it. If you piece all of the clues together, you can draw the conclusion that Java as a language is loosing steam, and Sun realizes this, but Java as a platform, (JVM), is not going anywhere. There are tons of compelling languages available now that run atop the JVM. Some dynamic, some static, some functional, you name the programming paradigm, and there is a language available to use to target the JVM.

The main point of this post is to show a clear distinction between Java the language and Java the platform. In my next post I will discuss which languages have the best change of being the new Java 3.0.