Skip navigation
ANNOUNCEMENT: is currently Read only due to planned upgrade until 28-Sep-2020 9:30 AM Pacific Time. Any changes made during Read only mode will be lost and will need to be re-entered when the application is back read/write.

Defining Java EE 6's Web Profile

Back on Monday, we featured Roberto

AWT and Swing windows get opacity options other than 1.0 and 0.0

Befitting the title, Josh Marinacci had a very hacky approach to providing transparent/shaped windows in our book Swing Hacks. Basically, what he did was to use the AWT Robot class to snap a picture of the screen right before showing the window, calculate the portion of the screen overlaid by the soon-to-appear window, and then use those pixels as the background of the window, for the parts that were to appear transparent. This served to make parts of the window transparent, which can also be used to provide shaped windows (in which case the transparent pixels are just around the corners and edges of the window, which itself is still rectangular).

As you might imagine, this was more a cute trick than a practical approach. We did say it was a "hacks" book after all.

But now, we're getting the real deal, as reported in a blog by Kirill


What Sarah Said Blog

Posted by kfarnham Feb 27, 2008

Starting our JavaOne 2008 preparations, with Sarah's pictures from previous years

On the infrastructure and community leads calls, we've started putting together our plans for JavaOne 2008. If you're familiar with our J1 presence in previous years, you know more or less what to expect, so here are some deltas: the booth number is 101, it's all the way to one side of the pavilion floor this year, and this year's booth is 25 x 50 feet, which will give project owners and community leads more demo space, which will be useful for things like Bruce Boyes' robotics demos.

Now, for everyone else, I'd like to give you a visual impression of our JavaOne activities, and since a picture is worth a proverbial thousand words, I'll enlist help from Site Producer and doer-of-all-things Sarah Kim and her Flickr photos.

This is the community leaders weekend, a meeting held in advance of JavaOne that lets the community leaders interact face to face with each other and with the infrastructure team (representatives from Sun, O'Reilly, and Collabnet). The above picture is me from two years (and about 40 pounds) ago, presenting an overview of the front page elements and how each is meant to generate interest in different parts of our projects and communities.

I think that was also the year that Bruno introduced Juggy, the Java Finch, to the group.

Anyways, the community leaders weekend is held in an unconference format, so we're able to discuss and adapt to whatever agenda attendees bring to the event. This year's will be held on Saturday, May 3 (optionally extending into Sunday... a "game time decision" we typically make on Saturday afternoon), and community leaders are invited to sign up on the Community Leaders Weekend wiki page.

A few days of setup later, the pavilion opens and you'll find us at the booth. The design of the booth offers counters at one end where community leads, project owners, and other community members can meet with colleagues, show off their stuff, answer questions, etc.

You can now sign up to staff that side of the booth on the Pod Staffing Signups portion of the Community Corner wiki page. And as JavaOne approaches, keep an eye on that schedule to see when your community leads will be there, so you can meet like-minded community members and peers.

Along with the talk at the pods and some couches in the middle of the booth for informal chats and laptop recharging, our other major attraction is the mini-talks.

These talks are 20-minute eyes-forward, conference-type talks, about your project, your community, some topic of interest to your community, etc... take a look at last year's talks to get an idea of the scope of the mini-talks. The booth provides amplified sound for your talk, a large plasma screen for displaying your slides, and has seating for 20-30 people, depending on arrangement. The talks are recorded and are sent out later as the Community Corner podcast. If you're interested, you can propose a mini-talk now by posting a title and abstract to the wiki at your preferred time, and getting it approved by a community leader.

So, that's your virtual tour of's activities at JavaOne. I hope we'll see you there in May to talk about your projects and what we can do to help further build the community.

Oh, and thanks to Sarah for the great pictures.

Also in Java Today, a new entry from Joe Darcy discusses How to cross-compile for older platform versions. "Besides compiling source code into class files suitable for the current JDK,javac can also be used as a cross-compiler to produce class files runnable on JDKs implementing an earlier version of the Java SE specification. However, just using javac1.6 -source 1.4 is in general not sufficient to ensure that the resulting class file(s) will be usable in a 1.4 JDK. While this will work for many programs, benign evolution of the libraries and platform can cause failures if the program is run on the older JDK.

A recently-developed page on the NetBeans wiki offers a tutorial for would-be plug-in authors, in Introducing NetBeans Plug-in Development. It describes key concepts for NetBeans plug-in development, and offers a complete tutorial that shows how to create and configure a module, add a window component so that it can appear as a new tab in the editor, and load the module into NetBeans.

In today's Weblogs, Frederic


This Temporary Life Blog

Posted by kfarnham Feb 26, 2008

The work-in-progress version of FCM closures

Forking was one of the inevitable consequences used as an argument against open sourcing Java, yet it's proving to be an invaluable aid in prototyping features for the next version of the language. You may already know about the Kitchen Sink Language project, an experimental javac branch where new ideas can be tried out. Nothing there is meant to be perfect or even to last, which is the whole idea of experimentation. Better to prove or disprove an idea off on a JDK branch than in a shipping product, right?

Of course, the biggest topic in the Java language today is closures, and one of the rival closure proposals has gone a similar route to provide an early preview of how it might work.

Stephen Colebourne, co-author of the FCM("First Class Methods") Closure proposal, has announcedthat an initial prototype is now available from the Kijaro project. "I'm happy to announce the first release of the First Class Methods (FCM) java prototype. This prototype [is for] anyone who is interested to find out what FCM really feels like." Based on JDK 7 b23 (the last JDK 7 drop before the Mercurial cutover), the prototype supports method literals, constructor literals, field literals, static method references, bound method references, constructor references, and anonymous inner methods.

Of course, this being experimental in nature, certain caveats apply:

Standard disclaimer: This software is released on a best-efforts basis. It is not Java. It has not passed the Java Compatibility Testing Kit. Having said that, in theory no existing programs should be broken. Just don't go relying on code compiled with this prototype for anything other than experimentation!

This seems like exactly the kind of good forking that was expected from the GPL release of Java. There's no confusion that the resulting code is Java™, no need to call in the lawyers. The fork is entirely experimental, meant not to last, and the results will guide development of the true JDK 7.

Whether or not FCM is your favorite closure proposal, or if you even want to see closures or anything like them in JDK 7, it's great that Stephen has committed his group's ideas to code and offered them up for all to try out.

Also in Java Today, the Aquarium announcesthat OpenSSO has released Build 3 of the open-source single-sign-on implementation. Key features in this release are new SAMLv2 profiles (Attribute Query, Authentication Query & Name ID Mapping), OpenDS replication, upgrade / co-existence, timed task changes in session and LDAP, legacy DIT support from Access Manager 7.x DIT, JBoss support, Geronimo support, and lots of issues fixed.

Details about a special Java Robotics event have been posted to a Java Meetup event page, scheduled for March 3. "This meeting is for both beginners and pros and involves some hands-on "play"-time, so if you'd like to participate, you'd want to be already proficient with Java. Shawn Silverman will present an informal 2-3 hour seminar on Embedded Java and Robotics, featuring Trackbot and SunSpot."

Ed Burns let us know about a "status update on the controversial JSF 2.0 JSR", which we feature in today's Weblogs. In, JSF 2.0 Update, he writes: "here's an ultra quick update on where the JSR-314 Expert Group is with JSF 2.0 developments. Everything relating to JSF 2.0 Expert Group developments is subject to change until the Proposed Final Draft version of the spec is released."

Turning some old wisdom on its head, Scott


This Charming Man Blog

Posted by kfarnham Feb 25, 2008

Of job changes and hypothetical injuries

One of the traits of the online era is that becoming a public figure is something that happens almost by accident. Indeed, it's been said that today's young people more or less expect to have an audience, from their blogs, MySpace and Facebook pages, podcasts, etc. And of course, the standards for how you treat public figures is generally understood to be different from how you treat friends, colleagues, and even complete strangers. In a nutshell, it's expected that public figures are more appropriate targets for criticism and even ridicule. They're famous; they can take it.

Even if they didn't mean to become famous in the first place.

I don't know if blogger Chet Haase minds some of the stuff being said about him. He recently set up a new blog, where he announcedhe'd left Sun to go to Adobe to work on Flex. This prompted various reactions and interpretations from many quarters, including a online comic by Eric Burke that portrays Chet, holding a bag of money, kicking the personification of Desktop Java in its nether-regions.

Seriously, dude, a little quality control, please?

The idea that Chet was "bought" with a big bag of money is an easy, lazy cynicism that we should all be over at this age. Let's take Chet at his word:

One of the things that attracted me to Flex, and to Adobe, was a client platform that enables very rich user experiences; transitions, animations, filters, and just darned good-looking UIs are all pretty exciting to this graphics geek. I hope to be able to help make Flex an even richer platform going forward.

Burke follows up the reaction to his comic by arguing that key people matter, that Chet's move is bad news for Desktop Java. Maybe so, and maybe it should be a "canary in a coal mine" moment that if Chet says Adobe's platform "enables very rich user experiences", that he's implying Java's doesn't. But even if that's the case, it's not for lack of trying, through some of Chet's efforts like the timing frameworkproject. And if Chet being over at Adobe means that the richness bar is set higher for Java FX, then so be it.

Chet's been a great blogger, author, colleague, and friend; we should wish him well.



Wrapped Up In Books Blog

Posted by kfarnham Feb 22, 2008

Do you have more comments than code? Should you?

There was a time when I would code by writing method signatures and writing an exhaustive javadoc comment for the method, before committing a line of actual code. It seemed like the "proper" way to do things, and sometimes it really felt like it was, particularly when I was basically doing my design in the form of comments, changing the design when the descriptions revealed holes or flaws in my thinking.

So, why don't I do this anymore?

Popular blogger and Google developer Steve Yegge argues that this kind of behavior is actually a defensive mechanism instinctively employed by intermediate programmers who are afraid of getting in over their head. He makes this case in a new blog, Portrait of a N00b, in which he compares this behavior to the temporal narratives told by young children, like the 2-year-old Emily featured in Malcolm Gladwell's The Tipping Point:

If you look back at the comments in my hypothetical code from 20 years ago, you'll see that I was doing exactly what Emily does: making up a temporal narrative in an attempt to carve out a mental picture of the computation for myself. These stories I told myself were a critical part of my mental development as a programmer. I was a child trying to make sense of a big, scary new world.

Most programmers go through this phase. It's perfectly normal.

So if preemptive commentary is the refuge of newbies, what does the seasoned pro do?

But when I write code in other languages these days, even in Java, it looks a lot more like this Emacs Lisp fragment than like the n00b code I was writing 20 years ago. It's denser: there's less whitespace and far less commenting. Most of the commenting is in the form of doc-comments for automated API-doc extraction. On the whole, my code today is much more compressed.

Steve calls the extraneous commentary metadata, and says that static types and data modeling are all the same thing. They may help organize the code during its creation, but are literally thrown away by runtime.

So what's with the "even in Java" crack? Steve argues that one reason Java is successful is that it is suitable for both the secure and the insecure programmer:

So you can write Java code that's object-oriented but C-like using arrays, vectors, linked lists, hashtables, and a minimal sprinkling of classes. Or you can spend years creating mountains of class hierarchies and volumes of UML in a heroic effort to tell people stories about all the great code you're going to write someday.

So if it sounds like a Java bash, it isn't, at least not necessarily. He ultimately gets to the fact that a large project in Java will ultimately both verbose and terse programmers working on the same code base. What do you do when half the programmers want to slam down code, and the others want to model until the cows come home? Steve argues for a middle way through the madness: developing a sense of when you need static typing, modeling, and commentary, and when you don't.

So, what kind of programmer are you? What would you like to be?

In Java Today, the Aquarium reports on an Updated OpenDS Roadmap: "Ludo just posted an OpenDS Roadmap to the USERS alias. The latest OpenDS 1.0 builds (b12, b11, etc) are looking very good, so the plan is for a Milestone 1 within the next few days, a M2 in a month, and an official 1.0 release in May 2008 - which, by a coincidence, is also when J1 2008 happens." Recent OpenDS activity includes continued progress on documentation, performance improvements, and more.

Continuing its series of interviews with Java Champions, the SDN has posted an interview with a prominent blogger Cay Horstmann: From Java Platform Improvements to Better Teaching: A Conversation With Java Champion Cay Horstmann. In a wide ranging discussion, he talks about optimization, testing, teaching, JSF, BlueJ, Java 7, and his reservations about the proliferation of scripting languages.

The latest Poll asks "Have you tried Scala?" Cast your vote on the front page, then visit the results page for current tallies and discussion.

Today's Weblogsbegins with Terrence


Expectations Blog

Posted by kfarnham Feb 21, 2008

Prominent developers ponder Java's future

In general, I'm not a big fan of panels at conferences. I think they're frequently self-indulgent and self-congratulatory. In voting for OSCON '08 sessions, I voted against one with the following comment:

Sounds a little bit like a "hold hands, sing kumbaya" type panel. Do participants have more to say than "hi, I'm from <country-name>, and I think open source is good."

Given that, I have to say I'm impressed with the participants and topics that QCon San Francisco pulled together for their panel discussion, What will the Future of Java Development Be? Consider the participants:

  • Joshua Bloch - Google's chief Java architect, Java Puzzlers co-author
  • Chet Haase - Swing team member, Filthy Rich Clientsco-author, co-owner of timingframework, animation, and other projects
  • Rod Johnson - Creator of the Spring Framework, member of servlet and JDO expert groups
  • Erik Meijer - Creator of LINQ
  • Charles Nutter - Co-creator of JRuby

OK, with participants like that, you can't help but have a good discussion, especially given some of the topics covered:

  • Can we modify the Java platform to utilize a core library with pluggable modules?
  • Do we ever want to remove code from the Java APIs, or create a new modular platform within Java?
  • Do you think the Java platform is already too complex?
  • Shouldn't programmers be able to understand and utilize new language features? Aren't we supposed to be intelligent?
  • If you have to use a rich IDE or some other tool in order to be able to program in a language, isn't that a bad sign?

Having said all that, I have to admit I haven't taken 50-some minutes to watch this panel before getting the page up this morning. It's too bad this one isn't available in an audio-only form for listening on the go, but for now, the only option is a web-embedded video. Still, these are the questions a lot of us have been kicking around recently, and it should be well worth the time to hear what this particular group has to say on the topics.

Also in Java Today, the Little Springs Design blog reports that customers still want their mobile apps developer in Java ME, in the blog Java ME is dead. Long live Java ME. Despite the growth of the mobile web, the blog says four the company's six first quarter projects use ME. "Why are they using Java ME? Because they need to store some of their application logic and/or data locally. Because the app or data needs to be available without the network. Because the application would be dreadfully slow as a web app. Because they are creating a push messaging client that needs more rich interaction than simple SMS (and better interoperability than MMS)."

While implicitly conceived for C/C++ developers, the Intel Software College article 8 Simple Rules for Designing Threaded Applications offers a sufficiently high-level view to be of use to many Java developers dealing with concurrency in the multi-core era. Author Clay Breshears writes, "multithreaded programming is still more art than science. This article gives 8 Simple Rules that you can add to your palette of threading design methods. By following these rules you will have more success in writing the best and most efficient threaded implementation of your applications. "

In today's Weblogs, Wolfram


The State I'm In Blog

Posted by kfarnham Feb 20, 2008

The closures debate and the bigger picture

Your editor is back in Atlanta, after a four-day trip to Grand Rapids, MI (and yes, it was cold and snowy... that's what winter's supposed to be like), and catching up on things here after being online only enough to get the front pages up Monday and Tuesday.

Looking at what's been going on, the thing that stands out is the current poll. Not just the results, but the participation, and the side effects. I always knew that sooner or later we'd want to get a sense of how the various closure proposals were doing, and that it would be a poll that got a lot of votes. After being up for just five days, 1300 people have voted, making it far and away the most active poll we've run in a while.

Perhaps more important is that along with discussing the major proposals and their merits, a few people are asking the meta-questions where are we going with all of this, and whose choice is it to make anyways?

We feature two prominent blogs on this topic on the front page today, starting with Stephen Colebourne, co-author of the "First Class Methods" (FCM) closure proposal, who has posted a blog Evaluating BGGA closures. He notes his obvious bias and starts off asking a pair of bigger questions. "The closures debate is really a touchstone for two other, much broader, debates. The first "what is the vision for Java". There has been no single guiding vision for Java through its life, unlike other languages." He contrasts this with the effective "ownership" of other languages by individuals, like C# (Anders Hejlsberg), Perl (Larry Wall), Python (Guido van Rossum), C++ (Bjarne Stroustrup), and Ruby (Yukihiro Matsumoto).

The impact of this lack of guiding vision is a sense that Java could be changed in any way. We really need some rules and a guiding Java architect.

The second touchstone debate is "can any language changes now be successfully implemented in Java". This is generally a reference to generics, where erasure and wildcards have often produced havoc. In the votes at Javapolis, 'improving generics' got the highest vote by far.

The result of implementing generics with erasure and wildcards has been a loss of confidence in Java language change. Many now oppose any and all change, however simple and isolated. This is unfortunate, and we must ensure that the next batch of language changes work without issues.

Despite this broader debates that surround closures, we must focus on the merits of the individual proposals.

Stephen links to a similarly-concerned blog by Ted Neward, who wonders Who herds the cats?

Unfortunately, the two most recognized "benevolent dictators" of the Java language, Neal Gafter and Joshua Bloch, are on opposing sides of the aisle on this. Each has put forth a competing proposal for how the Java language should evolve. Each has his good reasons for how he wants to implement closures in Java. Each has his impressive list of names supporting him. It's Clinton and Obama, Java Edition. The fact is, though, that when these two disagreed on how to move forward, lots of Java developers found themselves in the uncomfortable position faced by the children when the parents fight: do you take sides? Do you try to make peace between them? Or do you just go hide your head under a pillow until the yelling stops?

This is the real danger facing Java right now: there is no one with enough moral capital and credibility in the Java space to make this call. We can take polls and votes and strawman proposals until the cows come home, but language design by committee has generally not worked well in the past. If someone without that authority ends up making the decision, it will alienate half the Java community regardless of which way the decision goes. The split is too even to expect one to come out as the obvious front-runner. And expecting a JSR committee process to somehow resolve the differences between these four proposals into a single direction forward is asking a lot.

So what do you think? Does Java need a "benevolent dictator"? Has design-by-committee led to a fear of change? Will we have neither closures in Java 7, nor something as seemingly simple as switch-on-String? And if Java does need someone to make the call, who is it, and do they have the clout to make a decision stick?

Also in Java Today, a NetBeans wiki page offers a complete, step-by-step introduction to creating Mozilla application addons with NetBeans. "You can easily setup NetBeans to create Firefox Addons for the following: Mozilla Firefox, Mozilla Thunderbird, Mozilla Suite 1.x, Netscape, SeaMonkey, Flock, Sunbird , and Nvu. This can be achieved using the foxbeans module for NetBeans available at the NetBeans Plugin Portalwebsite."

In today's Weblogs, Kirill


The Blues Are Still Blu Blog

Posted by kfarnham Feb 18, 2008

More developers want to try out Blu-Ray Disc Java

One of the big deals of last year's JavaOne was an entire day dedicated to the use of Java in interactive television applications. The ME-based Multimedia Home Platform (MHP) is popular for ITV applications in Europe, and the CableLabs industry group recently launched the OpenCable project on to define a Java-based middleware layer for further interactive TV applications.

One of the most prominent stories, of course, is Blu-Ray Disc Java (BD-J), the MHP-based API for highly interactive applications running on Blu-Ray Disc high definition movie discs. With Blu-Ray having won the high-definition format war -- Toshiba just announced yesterday it is abandoning HD-DVD -- this looks like an exciting field to be in.

A problem for interested developers is that the BD-J spec remains available only to licensees, at a fairly dear cost (we're talking five figures, in US dollars). At JavaOne, speakers on a BD-J panel said that the Blu-Ray Disc Association was aware that some sort of overture needed to be made to open-source and independent developers for whom the full-blown spec-licensing path wasn't appropriate, but it doesn't seem like we've heard anything on that front lately.

Still, Sun remains interested in talking up BD-J to developers. In Java Today, we feature the SDN video Deep Dive: Blu-ray Disc Java, in which Sun's Blu-ray Disc (BDJ) architect Bill Foote discusses and demonstrates some of the powerful capabilities of BDJ, the Java platform for high-capacity Blu-ray Disc optical media device. See examples of BDJ applications such as interactive video-based menus, Blu-ray disc-based games, and more.

Also in Java Today, "the LinAlg project is developing a linear algebra API that offers core features and more for vectors, matrices, complex numbers, Quaternions, "and other linear algebra related stuff." The latest stable release, version 2.0, "completed the 2D and 3D Vector classes, added more basic Matrix operations and free rotation, added a core Quaternion class with basic Quaternion operaions, added a few algorithms: basic Gaussian algorithms for LES, [and] added a few tools for plotting Vectors and complex numbers.""

An updated release of the JavaFX Script plugin for the the newly released NetBeans IDE 6.0.1is available for download from the NetBeans Beta Update Center. This release includes several bug fixes and functionality improvements made to the plugin. For more detailed information about the changes, visit the change list page.



Seeing Other People Blog

Posted by kfarnham Feb 17, 2008

The GlassFish Day before GlassFish Day, and other conference news

In many ways, CommunityOnewas an outgrowth of special pre-JavaOne developer events: first NetBeans Day, then GlassFish Day and OpenSolaris Day and so on. After a point, it made sense for these events to co-locate and mingle a little bit.

On the other hand, what about the day before that, meaning the Sunday preceding JavaOne's Tuesday start? You're not doing anything, right? After all, the Community Leaders meeting is Saturday, and it usually doesn't stretch into a second day. So Sunday is pretty much free, except for coming down to Moscone to pick up your badge early.

And if you're going to be down there anyways...

In today's Forums, Eduaro Pelegri-Llopart announces GlassFish-related activities at Moscone (SF) the Sunday before JavaOne. "JavaOne this year is Tue-Fri, May 6-9, at the Moscone Center, in San Francisc CommunityOne is that Monday, and will have some GlassFish Content. We will have access to one of the rooms at The Moscone the day before, Sunday, and we are beginning to plan meetings for that day. *Ideas* might range from technical workshops on how to build GFv3 services, to hands-on advice from technical leads, to partner programs, to what-have-you. We will start a thread on this at the advocacy alias this next week."

Elsewhere in the Forums, Dirk Reske posts a Enterprise app + cluster question. "I have a question about clustering of enterpise applications. Currently we have an enterprise application containing an ejb and a jsf web application accessing the ejb's local interfaces. We are planning to cluster the application in production use. Since we have no experience in this field, there are some questions. Should put the whole enterprise app (ejb + web) on all cluster instances and access the ejb's through their local interfaces? Or should we put the web package on some of the instances and the ejb's on the other cluster instances and access the ejb's through their remote interfaces?"

Finally, rasped announces an interesting project involving Squawk on MINDSTORMS. "I have made a toolchain that can compile the vmcore and toggle the light sensor from the arm_mainmethod in os.c. Pls. see I will add more later to this post." 

In Java Today, the Aquarium notes a JSF 2.0 Preview Series over on Ryan Lubke's Blog. "JSF 2.0 should go final with Java EE 6 (and thus with the final release of GlassFish v3) but the implementation is done as a Separate Project within the community. Ryan is the implementation lead for JSF 2.0 and he has started describing the new features. The first entries cover ProjectStage(Production, Development, UnitTest, SystemTest, Extension) and Resources(things like JavaScript and the like)."

JavaBin, the Norwegian JavaUsers Group, has announced a call for presentations for the 2008 edition of JavaZone. The event will take place in Oslo, Norway on September 17 and 18. 2008 marks the seventh year that this event will be held. Last year was a massive success with more than 2200 attendees enjoying over 90 sessions in seven parallel tracks. The CFP closes on April 14, 2008.

The latest edition, issue 158, of the JavaTools Community Newsletter is out, announcing the addition of the 800th project to the community, as well as rounding up tool-related news from around the web, listing new projects and announcements from community projects, and offering a Tool Tip on saving development time with Jetty and Maven 2.

This week's Spotlightis on the OpenJDK JDK 6 project, a backport of the evolving GPL+CPE codebase to the JDK 6 spec, has posted its first source release. Due to IP encumbrances, some classes are not available as source, and are instead provided as "binary plugs" for Windows, Solaris (32- and 64-bit) and Linux (i586 and AMD64). More details about the project are available in Joe Darcy's blog and his initial project proposal. Those interested in the OpenJDK project will also want to check out the OpenJDK Developers' Guide, an early attempt to document everything needed by would-be contributors, from checking out code to contributing patches.

In today's Weblogs, John Ferguson


Here Comes A Regular Blog

Posted by kfarnham Feb 15, 2008

A big day for OpenJDK

Yesterday afternoon was an eventful one if you're on the OpenJDK mailing lists. All of a sudden, there was a flurry of activity, with one announcement after another. The most significant of which has to do with the OpenJDK community's first JDK 6 source drop.

I sent the URL for this to some friends on IRC and immediately got a question about JDK6uN, suggesting some pretty serious confusion about the various JDK projects. Let's see if I can help with that.

Since its launch, the OpenJDK project has been producing a GPL (with classpath exception) version of the evolving Java 7 standard. From the Free and Open Source Java FAQ:

We're open-sourcing these components from an early build of JDK 7. JDK 6 is the current shipping production release, and is stable. Hence we're releasing these components from the JDK 7 tree. At this stage, the only significant differences between the JDK 6 and 7 versions of these components are minor bug fixes and enhancements that have already been integrated into the JDK 7 tree. JDK 7 is the next feature release where all the action will be for innovation and new capabilities.

Now, of course, we don't really know what's going to be in Java 7, as there isn't even yet a JSR to specify its contents. So a while back, Joe Darcy proposal a JDK 6 project. In effect, this is a backport of these early Java 7 sources (which, unlike Sun's released JDK 6, are GPL+CPE), to the JDK 6 specification (viz., JSR-270).

To clarify, then: Sun's JDK 6 is release-quality, under the old licenses (BCL, SCSL, or JRL, as appropriate). JDK6uN is the more modular, "consumer JRE" update of that VM. And the OpenJDK 6 project is the GPL source release that isn't yet production quality.

OK, so we're all good with that, right? Good, because the Java Today section is all about OpenJDKtoday, starting with this announcement of the first source release from the OpenJDK JDK 6 project. Due to IP encumbrances, some classes are not available as source, and are instead provided as "binary plugs" for Windows, Solaris (32- and 64-bit) and Linux (i586 and AMD64). More details about the project are available in Joe Darcy's blog and his initial project proposal.

Meanwhile, a very early -- version 0.01, in fact -- release of the OpenJDK Developers' Guide has been posted as part of the OpenJDK project. "When the JDK was released under the GPLv2 license in May 2007, the need for a detailed document for contributors was anticipated. Translating rather sophisticated institutional knowledge into a format suitable for non-Sun employees is always a challenge. This document attempts to address the needs of developers who wish to participate in the future of the JDK." This initial release includes the "Repositories", "Change Planning and Guidelines: Fixing a Bug", and "Producing a Changeset" sections.

More source and fewer binary plugs will be coming in the next OpenJDK drop, according to Phil Race's message imaging and color classes binary plugs no longer needed (soon). "One of the most glaring holes to date in the openjdk sources are a couple of dozen 2D classes visible at the API level in the packages java.awt.color, java.awt.image, and java.awt.image.renderable. These have been held back from the sources (but included in the binary plugs) until we (Sun) established we could release these under GPL v2 +CP (ie same as most of the rest as OpenJDK). Just today we got the OK to do that, so at the next opportunity these classes will appear in the open jdk sources."

While we're talking Java 7, let's go ahead and bring up what's probably the most-discussed potential feature proposed for it. The latest Poll asks "Which Java 7 closure proposal do you support?" Cast your vote on the front page, then visit the results page for current tallies and discussion.



Unsatisfied Blog

Posted by kfarnham Feb 14, 2008

Of language evolution and Java's would-be successors

We've picked up a couple of nice opinion pieces to harangue about for an ordinary winter Thursday (your climate may vary, particularly south of the Equator). Both are motivated by pressures on Java from languages contending for mind-share and attention, notably Ruby.

We'll start with JBoss' Bill Burke:

I recently emailed the mandelbrot benchmark to a dynamic language evangelist colleague. Although benchmark results are usually pure propaganda, poor representations of how a language or framework is used in the real world, or even just plainly out of date with the latest versions of the technology, still, the performance of dynamic languages compared to Java in the example is quite embarrassing. Ruby, for example, is 500 times slower! Yeah, its hard to take seriously a benchmark that outputs to stdout, but still, if you look at the code you’re thinking, WTF is Ruby doing that causes so much overhead?

Now, when I forwarded this benchmark to my evangelist colleague, he immediately accused me of trying to put down or stamp out any challenge to the “One True Language” (Java). Its not about putting down or stamping out. Its about testing whether or not a language is a viable application platform. The thing is, if the dynamic language crowd is going to position itself as a replacement for Java in application development then they are going to have stop giving silly rationalizations for their shortcomings and promoting myths about their language and Java. This, and this alone is what irritates me about this crowd. Let me give you some examples about the rationalizations and myths they try to pull over on us...

From here, his Dynamic Languages: Rationalizations and


Can't Hardly Wait Blog

Posted by kfarnham Feb 13, 2008

JDK 6 for Mac OS X still a work in progress

So, if you're a Java developer with a Mac, and if it's a 64-bit Intel machine (e.g., a Core 2 Duo, or one of those ginormous new 8-core towers), and you're running Mac OS X 10.5.1 or higher, then go ahead and start downloading the just-announced new JDK 6 preview release from ADC and then continue reading this blog.

Now, given the hue and cry raised late last year when Apple released their latest OS update, Leopard, without JDK 6, you have to wonder what's worse: these subsequent not-ready-for-production preview releases, or no JDK 6 at all? There's surely a contingent that feels strung along by Apple's behind-the-curve schedule. What if Apple bailed on Java altogether... would it be a good thing if it drove interest in Soy Latte, the port of BSD Java to Mac OS X, or if it prompted Java developers to abandon the Mac, as several have vowed to do? Or is it still important that Java remain an official part of the once-again-growing Mac platform?

Aside from the delay, another annoyance of being part of the Mac Java cargo cult is the odd distribution of the developer previews. They're posted to the ADC and made available to all members, even those operating at the free "online" level. However, all software distributed on the site is subject to an NDA. So even though it's anything but a secret, you technically can't talk about it publicly. Back in December, I had to ask are you really serious about this? and Apple's reply was an unequivocal "yes".

So, much as I'd like to discuss the features of this release in the blog and on the Mac Java Community page, I can't, and neither can anyone else. So if you want to see what's in the new release, you'll have to just go to ADC and check out the release notes yourself.

No, they won't tell you if there will be versions for 32-bit Intel or PowerPC, or when it might come out. Nevertheless, it does look like they've been pretty busy...

I can say that much without violating NDA, right?

In Java Today, we take a look at the Bluetooth message service project, whose goal is to "provide a simple and easy to use interface that users can use to send messages, images and files each other while maintaining anonymous." A discovery service has already been implemented, with new work focused on implementing connections and a server side program (based on the BlueCove API, which allows use of a PC's Bluetooth stack).

The SDN's New to Java Programming Center " helps new developers to the Java platform find what they need to set up their system, understand the various technologies, and create applications for the desktop, web, and devices." The site's major content areas focus on getting started and learning more.

In today's Forums, Dirk L. van Krimpen needs ideas for Protecting class files. "I am rather new to launching applets through te web. I uploaded already some applets to my home page and launched them using JNLP. They work really great, I can use all kind of behaviours to manipulate the scene and everything works as if they were inside my own computer. However, I am wondering now about the following. Would it be possible to hide my jar filles containing all the classes from being downloaded by every visitor. Honestly speaking, in the past I also got jpegs and similar things somtimes from a website. But I don't want that to happen with the class files developed during months and months of hard work. So, has somebody an idea how to protect ones work fom being downloaded so easily?"

In Re: please review nimbus compatibility, rbairaddresses the practicality of the titular request. "A 1.5 backport was the plan, but I'm not entirely sure how practical it is. The vast majority of the bugs we've been fixing have been in Synth (both bugs and additional features we needed to support Nimbus). However, there have also been a fair number of fixes to Basic, as well as to a couple Swing components and TitledBorder. We've also supplied a critical fix to java.awt.Paint. So the only way a backport would work correctly is if we could backport these fixes to Java 5 itself, and then deliver Nimbus as an addon. That could be possible (it actually just occurred to me while writing this), but I don't know for sure."

swpalmer wants to know about the plans for Video Playback. "It seems that JavaFX is meant to compete with Flash where traditional Java applets have failed. To that extent is there a plan to included a modern AV codec (e.g. H.264) like Flash has, either as some sort of library for JavaFX, or as part of a general solution for the JRE?"

Today's Weblogsbegins with thoughts On the reuse side of things from Frederic


I'll Be You Blog

Posted by kfarnham Feb 12, 2008

Re-introducing and reconsidering reflection

Today's feature article went through a number of rethinkings and rewrites, in part because it involved a mix of both beginner and advanced concepts, which posed the risk of being a jack of all trades, master of none. Over the series of a couple of passes, we reworked it to be more of an introductory piece, for the benefit of the new Java developer -- there are many developers picking up Java for the first time every year, and not all of them have seen this stuff before -- but with hints of how the techniques can be applied to do some very interesting things.

For example, as part of his introduction, author Albert Attard writes:

Reflection provides a higher level of abstraction. In other words, reflection allows us to examine the object at hand and act accordingly during runtime. For example, imagine you have to perform the same task, such as searching for an instance, on more than one kind of object. You can either write some code for every different kind of object, or you can use reflection. As you may already have realized, reflection can minimize maintenance as the same code, since by using reflection, your instance-searching code will work with other classes.

Now that struck me as kind of interesting, because if you think of the justification of that use-case it may seem familiar... because he's describing a "cross-cutting concern", something that we were talking about a few years ago when Aspect-Oriented Programming had a modest burst of popularity. But rather than needing a whole new compiler or runtime, as is sometimes the case with AOP, consider cases where reflection might make sense for these cross-cutting concerns. If you wanted a debugging method to get all the fields of a class, you could overridetoString() in all your classes, or you could just write a reflective method to grab the fields of an arbitrary object and concatenate them into a big StringBuffer. Another cross-cutting concern: calling arbitrary methods in new threads. AOP could do it, but so could a reflective "fire and forget" class that pulled together a method invocation and invoked it on a thread.

Not for nothing, reflection is a popular technique with many Java developers. If you haven't tried it out yet, then start with today's Feature Article, Reflection in Action by Albert Attard. In it, he shows how to create arbitrary classes at runtime, and how to discover and use their fields and methods. He also discusses the performance considerations of reflection, and when the technique is and isn't appropriate.

The latest Java Mobility Podcast is Java Mobility Podcast 37: Announcements for M&E Developer Days. This week Roger and Terrence recap some of the announcements from the Mobile and Embedded Developer Days. You'll also hear an excerpt from James Gosling's MEDD keynote address.

In Java Today, Lars Westergren has posted a Beginners Guide to OpenJDK Contributing, based on his presentation from Javaforum Stockholm in December 2007. "It is intended as a quick "getting started" guide for those who wish to participate in the OpenJDK project. All the information was already out there, but spread over many different sites and I thought it needed summing up in one place so beginners could see step by step what they need to do to get a patch accepted." Contents include information about obtaining and building the code, the contributor agreement, testing, creating patches, and more.

According to a recent post at The Aquarium, "WiseMan, the WS-Management Java implementation has now become a part of Metro (the GlassFish Web Services stack) community. WiseMan provides both client and server side APIs for building Manageable applications. Jean-François Denise is reporting on the road traveled to provide the WS-Man implementation and make fit best into the existing Metro technology. The Web Services Connector for JMX builds on top of WiseMan to provide connection with WS-Man client tools such as Windows Remote Management much like OpenDMK is a window to the SNMP world.

The EclipseToNetBeans wiki page is an effort to enable a smooth switch from Eclipse to NetBeans. "The challenge for us, NetBeans folks is that we want your transition curve to be smooth. We don't want you to learn things which will ask you to devote a large chunk of your time just to get used to the features of NetBeans. As far as possible, we want it to be not more than 3-4 steps before you can resume working with your existing Eclipse projects in NetBeans." The page offers step-by-step instructions for downloading, installing, and using NetBeans' Eclipse Project Importer. Related documents offer guidance to importing different kinds of Eclipse projects, improved Eclipse-like key bindings, and more.

In today's Weblogs, R


Merry Go Round Blog

Posted by kfarnham Feb 11, 2008

Silly ways to burn CPU cycles

I wasn't sure if I could put Greg Colvin's latest Artima column,How To Go Slow, on the front page today, because his examples of bad programming are in C++ and its overall relevance to Java is perhaps more by analogy than anything else.

But still, even if you rarely or never use C++ (like me), I'll bet you can see that

      if (!data_available)
         goto loop;

sucks, and

      if (!data_available) {
         goto loop;

sucks somewhat less. I imagine many of you did a mental port of those examples to:

    while (! dataAvailable()) {}

    while (! dataAvailable()) {

Granted, you might have hard-coded your favorite value forThread.sleep(), or just usedThread.yield() instead. Or heck, maybe you thought of ditching the polling altogether and making your code justObject.wait() here for a Object.notify()to be called from dataAvailable(). Or maybe you thought of a nice, clean use ofjava.util.concurrent.

Whatever the case, Greg makes great points about how fairly simple code can have ruinous effects on performance. Some of the topics he points out aren't obviously bad at first, but depend on implementation details. His "thrashing" example shows the performance differences of working through a two-dimensional array by column or by row -- due to the arrangement of the rows in memory, proceeding by row often means the next cell you need is typically in the pipeline, cache, etc., just before you need it. The column-oriented version of the code isn't obviously bad, but it ends up being far less performant in real life. Aside: it would be interesting to know if Java behaves the same way. His example of "hanging" is also a textbook case of deadlock... just replace the acquire calls with Javasynchronized statements.

If you don't mind doing some mental ports to Java, there's a lot to enjoy in his column. It's well worth remembering how the little things add up after you do them a few million times.

In Java Today, the Rio project has announced Rio 3.3 M1, the first official update for the Rio project in quite some time. "Rio is an open source technology that provides a dynamic architecture for developing, deploying and managing distributed systems. Rio provides QoS based management for distributed systems, providing a policy based approach for fault detection and recovery, scalability and dynamic deployment." New features include dynamic proxies for associations, a smart proxy framework, better POJO support, a new UI, a new command-line interface with an interactive shell, updated documentaiton, and many bug fixes and improvements.

Interested in JDK 6 Update N, also known as the "consumer JRE", but want to find out more? A Java SE 6 Update N Early Access FAQ document provides general and installation information, a description of the Java Kernel, the new plug-in, and more.

The latest edition, issue 157, of the JavaTools Community Newsletter is out, with tool-related news from around the web, a brief comment on JavaOne session proposals, new projects in the community, and a Tool Tip on using JFeature for tracking your software requirements.

In today's Weblogs, John


Times Like These Blog

Posted by kfarnham Feb 8, 2008

The conference proposal review slog

Yesterday, I mentioned Tor Norbye's blog on Why Your JavaOne Submission Was Rejected, and I was sufficiently inspired to do my duty to my employer and work through the 80-some Java-related sessions submitted for the O'Reilly Open Source Convention. So that was yesterday afternoon, and then some.

I went backwards through the proposals' default sort order, to counter any directional bias... though this still tends to cluster proposals by topic if they all start with the same word. And yes, there probably ought to be something in O'Reilly's web app to just apply a random sort order on the search results, to make it more fair.

Anyways, looking back, it's interesting that I didn't give any "1"s on our 1 out of 5 scale... since scores are averaged among a small number of reviewers for each session, giving a proposal a 1 is effectively a veto. And to be sure, I don't mind killing stuff that is obvious garbage: incomprehensible drivel, corporate sales pitches, and outright spam. I gave out a bunch of 1's last year. This year, the floor at least was raised: the only ones I truly hated were sessions on long in the tooth topics that aren't going anywhere interesting (enough about Axis 2 already!) and one web 2.0 proposal that seemed to be an exercise in buzzword bingo, using Tim O'Reilly's famous What Is Web 2.0 as the answer key. And while those proposals weren't so hot, they weren't deserving of instant death. I'll leave that for the next few reviewers to work through the queue.

But enough negativity... what was good? I shouldn't get ahead of myself, since I've only got one vote, but there were some very appealing proposals about JVM internals, Java FX, the offshoots of the GPL'ed ME VMs, and some interesting projects I wasn't aware of. I think there were fewer projects as the focus of proposals than last year, but then again, but then again, there was a trend this year away from talks just about one project and more on integration, process, and context. All of which should make for good talks.

A friend of mine just turned down a offer to write half of an upcoming Java book, citing the crunch of conference season. A lot goes on to put on these sessions, and the people who propose and deliver conference sessions deserve the applause they get, because it's not easy.

Speaking of conference sessions, the latest Java Mobility Podcast is Java Mobility Podcast 36: James Gosling's MEDD Keynote Address. This week Roger and Terrence recap some of the announcements from the Mobile and Embedded Developer Days. You'll also hear an excerpt from James Gosling's MEDD keynote address.

JavaOne acceptances went out this week, and according to today'sWeblogs, Fabrizio


Best Of You Blog

Posted by kfarnham Feb 7, 2008

So who's speaking at JavaOne?

The moaning and cheering in my e-mail, IM, and IRC back-channels this week is the annual indication that the JavaOne acceptances and rejections have gone out.

So, how does the program committee decide who makes the cut? After putting up the front page, but before writing the blog, I Googled for "javaone 2008 rejected" and the first hit is fromNetBeans developer and JavaPosse member Tor Norbye, called Why Your JavaOne Submission Was Rejected:

I was on the review committee for one of the tracks, so I got to see the proposals as well as the reasons for rejecting many of them. I thought I'd write these up, both to explain to the many submitters what might have gone wrong, as well as to give some tips for how to improve your chances next year. I'll probably link back to this post around the time submissions for JavaOne 2009 open up later this year.

Among the flaws Tor cites in rejected proposals: not enough details, not general interest, submitted to the wrong track, crowded topic, and the fact that they only had 20 spots to hand out.

But what if you got accepted? Robert Buffone has posted a narrative of his experiences proposing, preparing, and delivering a session at JavaOne 2004 in the JavaLobby article So you want to be a JavaOne Speaker.

JavaOne just sent out their acceptance and rejects on Friday. Thankfully I got a congratulations one. I originally wrote this article about my first experience speaking at JavaOne a few years ago and it has some useful information but it also is just a interesting perspective on the whole process.

All of this conference talk reminds me that the CFP for the O'Reilly Open Source Convention just closed a few days ago, meaning I've got something like 80 sessions to review this week... maybe over a hundred once I look at the web apps, desktop, and security tracks. That's gonna take a while...

Also in Java Today, the OpenJDK Project has a new group, and two new projects. The conformance groupwas proposed to discuss conformance testing and compatibility issues, and approved by the OpenJDK Build Group. The Haiku Portproject exists to "bring first-class support for Java technologies to the Haiku operating system", Haiku being a re-creation and continuation of BeOS. Finally, the JDK 6 project exists to "produce an open source and compatible implementation of the Java SE 6 specification."

ACM Queue authors Mark Callow, Paul Beardow, and David Brittain lay out the challenges and rewards of mobile game development in Big Games, Small Screens. They stress the importance of early design and deployment decisions, and advocate a Java-based approach: "dealing with multiple platforms and the need to manage a reasonably sized development team leads to placing great emphasis on up-front planning and design of a game. Right from the start, the developer needs to consider what the target platforms are, will be, and could be. If a reasonable return on development investment is required by earning revenue from as many users as possible, then the developer will most likely look at Java games running on today's mass-market handsets, as this gives them access to about 60 percent of the market. "



Monkey Wrench Blog

Posted by kfarnham Feb 6, 2008

"Puzzling" features considered harmful?

It may be a first: a puzzler on a feature that hasn't even been approved for inclusion in the Java language yet. Of course, it helps that the source of this puzzler is Neal Gafter, co-author of both Java Puzzlers and the so-called BGGA Closures proposal, Gafter being one of the two "G"s (James Gosling is the other).

In Closures Puzzler: Neapolitan Ice Cream, he writes,

This puzzle explores the question of whether people experiencing the same thing through different senses are really experiencing the same thing at all. What is the program's output, and why?

This puzzle uses Java Closures, so if you want to try it you should download the prototype here. You can download the puzzle sources here.

Without getting too deeply into the specifics of the puzzler and why it involves enums, there very idea that closures are already fertile ground for puzzlers, i.e., non-intuitive behavior, strikes some as a code smell (a phenomenon that Neal makes an oblique reference to earlier in his blog). Kirill Grouchnikov confronts this issue head-on in his blog, And so it begins - the first closures puzzler.

Neal Gafter has posted the first closures puzzler. I guess the second edition of Java Puzzlers is in works, and closures will be a hefty addition to the book. If anything, this makes me really sad.

Saying that the kinds of weird side-effects and unintuitive overloads typified by the book's various puzzlers are atypical of the real-world Java code he works with, Kirill goes for the money quote:

I would even go as far as to say that a feature implemented in a way that results in at least one puzzler is not a feature worth having in the language.

Check out the comments on the blog for the debate between Neal and Kirill. I imagine that for every programmer who thinks Kirill's dismissing closures and their necessary details too quickly, someone else is probably saying "why weren't we thinking this way before the generics fiasco?"

Debate ahoy. Enjoy.

Also in Java Today, Geertjan Wielenga continues a NetBeans tutorial series on JavaLobby with the brief tutorial, How to Add Resize Functionality to Visual Applications in Java?Picking up from a previous article that showed how to use theIconNodeWidget class, he shows how to create resize borders that activate when hovered over, and which can be used to resize the icons, including their respective images.

Eduardo Pelegri-Llopart notes GlassFish and NetBeans support for Grails 1.0 in an entry on The Aquarium: "Good news for Grails fans: Grails 1.0 is Now Available and its adoption seems to be increasing: GlassFish is already in the list ofGrails Supported Platforms, and Vivekand others are going to continue to improve on that. On the tools side, Martin and Brian report on early Grails support in NetBeans 6.1 M1 (but some growing pains still) and we had already reported on Grails and Hudson."



Erase/Replace Blog

Posted by kfarnham Feb 5, 2008

Garbage collection gets even more clever

Garbage collection is one of those topics where the smart developer acknowledges how much he or she doesn't know about how it really works, while the know-it-alls dispense advice whose freshness date expired sometime around Java 1.3. Does garbage collection, by its very nature, always bring your VM to a complete halt? Should you use System.gc() to periodically clean things up manually? Or should you remain blissfully unaware of such concerns and create objects to your heart's content?

For those inclined to be too clever by half and manage their own memory (and hey, if you really like memory management, there's always C... but I digress), you might want to get up to speed on just how clever the JVM's garbage collector already is.

Jon Masamitsu describes the JVM's various garbage collectors in a recent blog, Our Collectors. He shows six collectors and describes their strategies and side effects, along with how to use or disable them by means of -XX flags:

  • "Serial" is a stop-the-world, copying collector which uses a single GC thread.
  • "ParNew" is a stop-the-world, copying collector which uses multiple GC threads. It differs from "Parallel Scavenge" in that it has enhancements that make it usable with CMS. For example, "ParNew" does the synchronization needed so that it can run during the concurrent phases of CMS.
  • "Parallel Scavenge" is a stop-the-world, copying collector which uses multiple GC threads.
  • "Serial Old" is a stop-the-world, mark-sweep-compact collector that uses a single GC thread.
  • "CMS" is a mostly concurrent, low-pause collector.
  • "Parallel Old" is a compacting collector that uses multiple GC threads.

He also describes a promising new collector in his diagram:

That box represents the new garbage collector that we're currently developing called Garbage First or G1 for short. G1 will provide:

  • More predictable GC pauses
  • Better GC ergonomics
  • Low pauses without fragmentation
  • Parallelism and concurrency in collections
  • Better heap utilization

G1 straddles the young generation - tenured generation boundary because it is a generational collector only in the logical sense. G1 divides the heap into regions and during a GC can collect a subset of the regions. It is logically generational because it dynamically selects a set of regions to act as a young generation which will then be collected at the next GC (as the young generation would be).

A lot of people understand garbage collection as simply the brute-force "stop the world" exercise that causes AWT apps from 10 years ago (on 10 year old hardware) to seize up, and thus give Java a bad name in some camps. But with a decade of optimization, GC has gotten more clever and more powerful and with some exceptions (which are probably the domain of real-time Java), is probably not something to attempt to second guess anymore.

Also in Java Today, a recent SDN Mobility Tech Tip looks at strategies for reliable, embedded monitoring systems, in Ultra-low Bandwidth Communication with Java ME. "In the U.S. Department of Defense as well as in commercial industries, there are several applications that need wireless communication at low data rates (and consequently with low power consumption). For instance, most modern vehicles now contain tire pressure monitoring systems. [...] In this tech tip, we're going to explore how to use Java ME and Sun SPOT technology to create a low-bandwidth wireless system to read sensor data."

Richard Hightower continues his introductory series to JSF in Getting started with JavaServer Faces 1.2, Part 2: JSF life cycle, conversion, validation, and phase listeners. "This sequel gives you a firm grasp of JSF's more-advanced features: custom validators, converters, and phase listeners. Along the way you'll gain an understanding of the JSF application life cycle."



This Is A Call Blog

Posted by kfarnham Feb 4, 2008

Class names considered harmful? The weird world of the Da Vinci Machine project.

It's not like the JVM lacks support for languages other than Java. One tally shows over 200 languages on the JVM. So it's obviously a perfectly suitable environment for other languages. But is itideal?

We've heard for a while the debate over providing better VM-level support for dynamic languages by, among other things, adding aninvokedynamic byte code. But it seems that most of us weren't aware how far Sun was taking its research in this realm. It's evolving a whole new VM, based on the current JVM, to be optimally suited to dynamic languages.

John Rose blogs about the introduction of the multi-language Da Vinci Machine project in his event-recap blog Bravo for the dynamic runtime!

"This week several of us from Sun attended the Lang.NET Symposium. The symposium was intensely technical and not too large to fit into a single room, so the presentations and conversations were a fine exercise in what one might call N-3: Nerd-to-Nerd Networking. Sometimes they were even downright inspiring—bravo Anders, Jim, Erik, Gilad, Peli, Jeffrey. Our hosts kindly welcomed presentations from three of us at Sun: Dan Ingallsshowed everyone the Lively Kernel, while Charles Nutter and yours truly introduced the Da Vinci Machine project."

The blog goes on to draw comparisons between the dynamic evolution of Microsoft's CLR into the Dynamic Language Runtime (DLR) -- along with such remarkable tidbits as Microsoft apparently no longer attempting to improve CLR's rudimentary JIT -- and the equivalent transformation of the JVM into the Da Vinci Machine project. This project promises to go a lot farther than a single new bytecode:

We are extending the JVM with first-class

JavaOne acceptances go out; OSCON deadline looms

Have you gotten your JavaOne session acceptance or rejection yet? Robert Cooper was asking me the other day if these had gone out, and I said I didn't know, particularly as I didn't submit anything this year. But now I see over on JavaLobby that they started getting acceptances and rejections last night. "The long awaited moment has arrived at last! Over the past hour or two, the rejection slips have been rolling in. Those who submitted proposals for doing presentations at JavaOne 2008 have received the "yay" or "nay" by this stage. How did you do? How many rejections did you get?"

One of the stated goals for this year's talk was to bring in a lot of talks about stuff that runs on the Java Virtual Machine, so it will be interesting to see if there are a lot of talks about JRuby, Groovy, Jython and the like.

Meanwhile, Monday at midnight, PST is the deadline for the O'Reilly Open Source Convention's Call for Papers. "Participants at the O'Reilly Open Source Convention want to hear about real-world scenarios using open source, ways they can be more productive or write better code, and what's new. Please submit original session and tutorial ideas that focus on hands-on instruction and real-world examples."

Java has a track of its own at OSCON, and certain Java topics might also fit into the Administration, Business, Databases, Mobile, and Web Application tracks.

Last year's OSCON had a number of sessions, and hopefully we'll see a good turnout this year as well. One thing I've heard from the back channel is that the "State of ____" or "____ Annual Update" talk is likely to be more or less automatically rejected, so speakers for long-running projects will want to look for an "angle", a "hook" to tell the program committee and attendees why their talk matters. Discussing this with Roger Brinkley a few weeks back, I suggested a good approach for the Mobile & Embedded community would be to show the practical results of open-sourcing Java ME: VMs for new devices, offshoot projects, etc. Similarly, an OpenJDK talk that focused on what the open-sourcing of Java SE has accomplished -- spawning significant independent projects like IcedTea and SoyLatte-- is the kind of thing that could win over the program committee.Disclosure: I'm on the OSCON program committee, but what I'm doing here is passing along the "buzz" from the committee mailing list, not my own preferences.

So, one conference mails out its responses while the next prepares to close its CFP and start going over the proposals. Another busy year in Java...

Hopefully, someone from Sun will be talking at OSCON about the company's $1 million Open Source Community Innovation Awards Program. In Java Today, we link to another community participating in this program. The OpenJDK Community has posted details of its OpenJDK Community Innovators' Challenge and is welcoming proposals. "The OpenJDK Community and Sun Microsystems, Inc. are pleased to announce the OpenJDK Community Innovators' Challenge, a contest with up to $175,000 in awards, intended to encourage and reward developers working together in solving key problems, initiating new innovative projects that promote new uses for the code, developing curricula and training, and porting the OpenJDK code base to new platforms." Proposals can be submitted from now through March 2.

Patrick Gotthardt has announced a 1.1 beta release of the PgsLookAndFeel for Swing. "Today I have the pleasure of announcing the first beta version of PgsLookAndFeel 1.1. This release fixes numerous bugs that I fixed over the course of the last year or two and features some UI improvements that I have hacked together in the last 5 hours."

Somewhat inspired by the BD-J forum posts we've tracked this week, but surely more widely applicable throughout the development world, the latest Poll asks "would you develop applications for a closed platform?" Cast your vote on the front page, then visit the results page for current tallies and discussion.

In today's Weblogs, James Gosling throws his support behind one of the Java 7 proposals for Closures. "There has been a lot of chatter about the closures proposal penned by Neal Gafter. And, in particular, whether or not I support it. I absolutely do."


Filter Blog

By date: