Java Spotlight 4

[intro music]
Roger Brinkley: Welcome to the fourth edition of the Java Spotlight Podcast. I'm Roger Brinkley.
Terrence Barr: And I'm Terrence Barr.
Roger: In this edition of the podcast we'll do a news segment, we'll do a feature interview with John Julion Ceccorelli, the NetBeans development manager, and we'll finish up with a What's Cool section. So in the news this week about the JVM and the new plans, which are really not new plans, I guess I would say. But, Dalibor, why don't you take us into this one?
Dalibor Topic: Sure. At JavaOne, Henrik Stahl and Paul Hohensee presented Oracle's JVM strategy. It was already sort of announced back at the Oracle Sun Acquisition Strategy Webcast. We said that that we were going to merge the JRockit JVM with the Hotspot JVM, and at JavaOne, Henrik and Paul gave a bit more detail, saying that they would merge into a single JVM which would incorporate the best features of both JRockit and Hotspot on the basis of Hotspot, because we have more engineers that are familiar with the Hotspot code base than the JRockit code base.

The result of that will be contributed incrementally into Open JDK. And some of the existing value-adds, like JRockit Mission Control, will remain proprietary and will continue to be utilized commercially.

And of course Oracle will continue to distribute free - that means gratis - JDK and JRead binaries, which include some of the closed source goodies.

This convergence between JRockit and Hotspot is going to be an multiyear process. During the OpenJDK in Bath, Henrik and Paul added a bit more details explaining that they'll continue to provide Sun's Java for Business and JRockit Mission Control, JRockit Real Time and JRockit virtualization as value-adds that will continue to provide an enterprise support offering on top of the frame that is gratis Oracle JDK. That the overwhelming majority if JVM work will do will go into OpenJDK, a this includes the performance features from JRockit.

That will make this contribution I think the largest contribution someone's done to OpenJDK since the inception of the project. So all in all, I think this is great news. In Henrik's blog post, which is in the show notes, you can find a link to the slides from the JavaOne presentation, and of course you can find a link to the presentation itself, but you have to register to actually get the audio.

Roger: This really isn't a change in plan, it's just an implementation of what we said we were going to do back in the JavaOne time frame.
Dalibor: Oh, yeah. The press releases that came out on September 21st had a bunch of details about the roadmap for Java going forward, and it contained a lot of details about JDK 7.0 features and JDK 8.0 plans. And of course it contained a bunch of bullet points explaining the JVM strategy. But this blog post by Henrik adds a lot more color to it, of course, and contains the slides. So if you're interested in our plans for JRockit and Hotspot, go and check this one out.
Roger: Terrance, probably the biggest news of last week was the Oracle/Apply announcement, of their contribution to the OpenJDK project for OSX.
Terrance: Exactly. That was last weeks late-breaking news that Apple and Oracle announced the OpenJDK Project, where Apple will contribute most of the key components, tools, and technologies required for Java C7 implementation on Mac OSC, including things like the 32- and 64-bit Hotspot, VM, class libraries, networking, stack, and foundations for a new graphical client. They will be contributing that to OpenJDK. For more information, you can see my blog, terrancebarr@WordPress.com, or Henrik Stahl's blog, which is blogs.oracle.com/henrik.
Alexis Moussine-Pouchkine: Maybe something that people didn't notice so much was that Apple announced that they will actually have additional releases to their Java 6.0 version, both in the current Mac OSX version as well as in the next one. So it's not like they're totally done with their releases, they will have maintenance releases of Java 6.0.
Dalibor: And I should also add that Mike Swingler from the Apple team has posted to the Java Dev List, adding a few more details for Apples planned contributions. You can find a link for that in the show notes as well.
Roger: Let's move to the down to the GlassFish news. Alexis, what have we got here?
Alexis: One of the things we talked about recently was what version of Weld would be in GlassFish 3.1. So stepping back a bit, CDI (context independency injection) is a critical new piece of Java EE 6.0. There's really a lot to it. There's not just dependency injection, there's a lot about the C, which stands for context. And I really think this is a very powerful and interesting new feature of Java EE 6.0.

Now the implementation we use as part of GlassFish is called Weld and is developed by the JBoss folks. We integrate this as part of GlassFish. While this is new technology, some people have been complaining about the performance, the memory usage of Weld in its earlier releases.

So the news here is we have Weld 1.1 scheduled to be integrated really soon now. We actually have release candidates of Weld 1.1 in GlassFish 3.1. This release of Weld actually has a lot of enhancements in terms of the performance, startup time, performance at runtime, and well as memory consumption.

So I think there's really no reason to ignore CDI now together with GlassFish 3.1, or every other implementation that uses Weld or any other implementation of CDI. JBoss, for example, is coming out real soon now with a release of JBoss 6.0. This is really good for Java EE developers, that's more choice for them.

Roger: You've got another release kind of for paying customers.
Alexis: Right. A couple weeks back I talked about the press release we have for customers, and that was at the time for the 2.1.1 release train. We now have the first patch release for the EE 3.0 train, actually for 3.0.1. So this is 301 Patch1. This has a number of fixes that were integrated and that will show up as part of the 3.1 public release, open source version, if you will, later this year or early 2011.
Roger: All right. Let's switch a little bit. Events that are coming up. JavaOne on the first week in December will be in Brazil, down in Sao Paolo. And then the following week will be in China, in Beijing. I know that Terrance and I are going to both of those. We're going to be logging a lot of miles and a lot of time in a seat consecutively, when we fly from Brazil to China.

It's a good time, please, if you're in those areas, come up to see us, talk to us. Tell us about the things you're working on. If you've got something really exciting, tell us about that. We'll see about the possibility of putting you on as a feature interview in the podcast.

Let's turn now to our feature interview, which an interview that I did with John Julion Ceccorelli, who is the development manager for the NetBeans Development Platform. Let's go directly into that interview.

I'm here with John Julion Ceccorelli. Let's talk about NetBeans 7.0. You've got a beta release. Is 7.0 a revolutionary release or is it an evolutionary release?

John Julion Ceccorelli: I think 7.0 is an evolutionary release. It's aligned tightly with JDK 7.0, so the main theme of the release is support for language constructs in JDK 7.0. The language constructs are solid enough that we could build tooling around it, but we actually use the Java C as a binary as a parser. So when we drop one of the versions of Java C from the daily builds of JDK into the IDE, we can easily pick up all of the language changed that are implemented in a new version of Java C and you get all in the editor.

So the editor understands the new language constructs, it understands the project coin. And on top of that we've added a lot of hints there for converting from JDK 6.0 conventions to JDK 7.0 conventions to help you spruce your code if you want to start using the JDK 7.0 ways of coding, whether that be strings and switch or so forth, or multi-catch.

Roger: Let me ask you a question then. How do you handle this - obviously we saw Plan A, Plan B, when it came to JDK 7.0 and JDK 8.0. So how do you handle the things that made the cut or didn't make the cut for 7.0 and are going to into 8.0. How's that going to work with what you're doing?
John: Well, we work closely with the JDK team, and like I said, it all depends on what gets implemented in Java C. When they made the cut and they decided that certain things were going in and certain things weren't, they rolled back a few things that were kind of in very alpha state in Java C, and then polished up the things that were aligned for release, and then those are the ones that we went ahead and kind of put some more useablity features around. So that's what we've doing. We just stay flexible and support what's in the builds. As far as the language constructs go. Now obviously something big like modularity, that's not just a question of things being underlined correctly in the IDE, that's an entire change in the context of dependencies and so forth.

And so that's going to take more time for us to adjust our project structure and everything to deal with.

Roger: So you're kind of glad you got a little bit of a break there with modularity as it come up.
John: [laughs] We'll be ready for it when it comes. But it's a lot of work and I think that we all recognize that. Both the tooling side and the JDK side, we recognize that we need more time to kind of sort out the rough edges there.
Roger: Does this mean when a JDK 8.0 feature, somebody is working on the builds for JDK 8.0, that they'll just automatically appear within NetBeans or do you have to do some additional work?
John: There's a patch we have to apply. We don't do daily builds. We'd love to get to the point where the user could point to any version of the JDK and it would pick up that Java C and use its semantics for giving you editor highlighting and so forth. But there is right now a patch that we have to apply. And so it takes about a week of work for us to grab a drop of the Java C parser and apply those patches. There's very different ways in which you would use Java C from the command line and the way that we use it.

Java C from the command line, it runs across some broken code, it stops and says, "Hey, this is broken, " and it works out an error. Whereas as you're typing in the editor, you've constantly got broken code in there. So Java C needs catch that and keep going.

Roger: Tell me a little bit more about what else is in this release. You've got some stuff that's on the EE side as well, then.
John: One of the things that we're doing in this release is we're beefing up our support for WebLogic. You always had a WebLogic plugin on the update center to hook into WebLogic, but it was very minimal. Basically you could deploy it and that was about it. So now we're bringing it up, bringing it closer to the level of support we have for GlassFish. Not quite a close, because we have been working with the GlassFish team for a long, long time, and we just started working with WebLogic intensively. You can register it and you open it up in the services window.

You can see all the modules that you currently have deployed and launch the admin console. Do some limited administration from the services window of the IDE. You can deploy to it. And of course deploy on save works. Deploy on save.

So if you're writing a file, you hit save, it's going to get deployed to the server automatically without you having to redeploy the entire [inaudible 12:03] .

Roger: A question I had when I was out in New York City last week, and somebody came up to me as said, "What can you tell me about the differences between JDeveloper and NetBeans? Is NetBeans going to be around and is Jdeveloper going to be around?" And that kind of thing.
John: Lots of hand-wringing in the community, I'm sure. I was just talking with the vice-president, who's my boss, who's the head of JDeveloper. JDeveloper is primarily a tool that's focused on ADF and ADF tooling. NetBeans is the more all-purpose Java tool. We have two separate audience and two separate missions, and kind of two separate sets of requirements from our users, although we're both Java IDEs. So of course there's a large amount of overlap.

But the things that are really important to us, such as supporting the latest standard and really shipping with any latest release of Java EE or Java SE or Java Client, and being right there on the bleeding edge of where Java is going, are not so important to the ADF community.

So these are two products; there's still a need for two products. Having said that, we would love to harmonize more. And there's no reason why if we do some improvement in NetBeans that JDeveloper wouldn't love to pick that up. Whether that's the Matisse and so forth.

On the other hand, there are obviously areas where JDeveloper is more advanced than NetBeans. The database functionality in JDeveloper is outstanding. They have a fully-maintained UML plugin and whole modeling infrastructure, whereas we released our UML to the community in the last release.

We would love to be able to hand functionality back and forth, but I think that complete IDE interoperability, there' s been - it's just so difficult. There's just so much differences in the code, all the way up and down.

We've would love to be able to leverage each other's work, and we're looking at it. But it's not trivial. [laughs]

Roger: All right. Anything else we've got in this release?
John: Yeah. We've got GlassFish 3.1. GlassFish 3.0 came out With the real Java EE 6.0 the first release of Java EE 6.0 pack and GlassFish 3.1 that was more of a developer release. And GlassFish 3.1 really fills in all of the enterprise level functionality that enterprises need by clustering and so forth. For a developer I don't think there is a ton of new stuff in GlassFish 3.1 although I am sure I am going to get an email from the GlassFish team telling me that there is. What else have we got? We have Maven three integration. So first IDE to support Maven 3. And they just released a few weeks ago. Yeah we support Maven natively. We've got top notch Maven support. The guys have been really great at implementing it. There is no need to input a Maven project or create any additional metadata or anything. You just say open project, you navigate to your palm file, you select it and boom. It will open up. The IDE knows all the dependencies. It knows how to build it, and you are off to the races.

So Maven three has a lot of performance improvements. And there were a lot of bugs fix in it and so forth. And of course we still support previous releases of Maven because this is fully backwards compatible. So if you are using Maven, you should definitely check out our support because it rocks.

All right. So where are we going to find this thing?

Go to netbeans.org, it will be right there on the front page. Give us feedback on the aliases and try it out fire bugs, kick the tires. We are planning to release in March which is actually sooner than JDK seven will go out. Like I said the language constituents are solid enough that we can release in before support JDK7 at that point. We also need to get going on the release for the file.

So coding against JDK seven in March and then for actually running on JDK seven when JDK seven comes up, because we have got lots of other good stuff in the pipeline that we need to get going on as well.

Roger: Excellent. All right John thank you very much for your time today.
John: All right thank you. Thanks for having me.
Roger: So Alexis, so what is actually coming out as far as the support on the EE side.
Alexis: So first of all let say I am really glad that we have the support for JDK 7. I remember the time when JDK five was out and NetBeans was the first one to jump on it. And I had so much fun using the new language construct that I can't wait to start using NetBeans seven beta. As far as GlassFish 3.1 is concerned, there is lot of small incremental enhancements. First of all is support for GlassFish 3.1 which will ship probably just a little before NetBeans seven final. We have things like restart and debug mode, the ability to view remote logs, not just for service running locally.

One interesting feature I think here is the ability to deal with application-scoped resources. This is a file where you define all the resources you want. Package those as part of your app. And at deploy time, this is when the resource is created. So now NetBeans lets you actually author those resource files. And I think that that makes for a nice addition to both GlassFish and NetBeans.

So easier domain creation. If you want to create your own local domain with different ports, different settings from the default one that's fairly easy to do. So lots of small things. And one final thing is how NetBeans actually, and this isn't really relevant to GlassFish but more specific to Java EE, now has the ability when an EAR file that both the EJB and an application client container packaged together.

When you start and debug the big application the EAR file, it will actually two debugging sessions. One for the service side and one for the client side. And I think that makes for a really nice new feature in NetBeans. So for all the Vince Kraemer has lots of screencasts and details on his blog. And that will be in the shownotes.

Roger: I don't know about the rest of you guys, but I kind of thought it was interesting. They are really taking a real aggressive schedule coming out in March a little bit ahead of the JDK release and then coming up with a release after that. What do you guys think about that approach of that aggressive engineering schedule?
Alexis: I didn't really like it because I think to some degree the basis, the platform and lot of the infrastructure is already in place. So that enables for those small incremental but very valuable releases. So I like, I had been a user of NetBeans for ages. And every release has something relevant for me. So I don't know how they do it. But I see this release as giving a lot to lot of different folks. With JDK 7, Java EE, Maven, I really like it. I don't know how they do it. But I like the result. Yeah. And I think as long as they can deliver it is going to be a good piece there. So let's now turn our attention to the 'what's cool' feature. So Alexis what's cool for this week.
Alexis: Well since Dalibor was talking about jobs in the JDK Java SE space I'd like to mention that GlassFish is actually hiring as well. So we have jobs in the group. I think they are based in the US. There might be some other locations that are possible. But certainly go to Oracle.com/jobs and just search for GlassFish. We'd be happy to have more people on the team.
Roger: All right. Dalibor, you have got a whole bunch of things that you think are cool this week.
Dalibor: For me the really cool thing this week, Maurizio Cimadamore patch he posted on the Project Lambda Mailing List for closures. And he created a Lambda finer utility. So the idea as he posted is to find all potential anonymous inner class creation expressions that can be potentially replaced by Lambda expression. And this means you have to pass a secret hidden flag to the Java compiler and can let you know what sort of code can be made more efficient with Lambdas. I think this is something really fun to play with. There is a blog post [inaudible 20:34] from somebody who actually has taken the feature for a run and found some interesting things out. And in a similar vein, if you don't want to wait for Lambdas for JDK 8, you can actually try a similar finder out in JDK 7. In the latest JDK seven build 18 from this week, we have a diamond finder feature which again requires a hidden flag and it can tell you go and improve your code by using the diamond operator and just save a lot of typing in the future.

Beyond that we had Doug Lea who posted on the concurrence development list about his plans for the java. Util concurrent package. So if you're interested in where that is going, then make sure to check out the shownotes for Doug's plans for JDK seven and JDK 8.

Roger: All right. So my what's cool for the week is this interview that I did this week with John. I actually knew John he was a lowly writer. He was just a tech writer and he has now moved up to the NetBeans Development Manager and so I think that's kind of cool. You don't necessarily have to go through a technical path in moving up to that management circles. So I thought that was kind of neat and cool progression of someone's career in that direction. Thanks for listening to the fourth edition of the Javaspotlight podcast. I am Roger Brinkley. And I am Terrance Barr. And send your feedback to feedback@javaspotlight.org.

[music]



Transcript by CastingWords