[intro music]
Roger Brinkley: Welcome to the third edition of the Java Spotlight Podcast. I'm Roger Brinkley.
Terrance Barr: And I'm Terrance Barr.
Roger: And in this edition of the podcast, we'll do a news segment. We'll do a feature interview with Greg Bollella, who is the Chief Architect for Embedded Java Devices. And we'll finish up with a "What's Cool?" section. So, Terrance, let's bring in our Java all-stars. Again, this week, Alexi and Dalibor Topic. The first thing on the news is migration. And since I've been involved with from the beginning, we're actually migrating our underlying software coming from CollabNet, which was the piece that we've used since the beginning of our time, and moving over to the Keen Eye software as a base software.

If you have a project, you will not be migrated unless you make a request to be migrated over. And you can find that information on that request. The community manager, Sonya Barry, has written a blog on that. Please go to our show notes. You can take a look at some of that as to get an idea of what's happening there. Now, for a bird's eye view of how this actually works for you, Alexi, you're going through this right now with some of the GlassFish projects.

Alexi Moussine-Pouchkine: Yeah, we are. Actually, the projects like Jersey, Metro, Grizzly, Atmosphere, and a few others, are actually locked today and being migrated as we speak. There's going to be a second wave with the remaining GlassFish projects that will be fully migrated. And when we say migrated, it's not just source code. It's issue tracker, it's the Wikis, it's all of it, right?
Roger: Right. It's all of the CollabNet infrastructure that we had before. And we've actually gone through some of this already. The forums that were the generic forums were moved over a couple weeks ago. There's been some problems with some of that, but we're addressing those and cleaning those up as we go along. So, it appears to be moving in the right direction, at least so far. Anyway, the second thing in the news here, older news. The Java Platform Micro Edition, Oracle Java Wireless client, was released to licensees back in the middle of October, around October 18th. This is version 2.3, and it's a pre-integrated, optimized solution for deploying Java to mobile platforms. So, Terrance, this is a CLDC implementation, but a lot of people aren't going to see this for a little bit. So, why would this be important to the developers?
Terrance: Yes. So, the Oracle Java Wireless client, or the Sun Java Wireless client, as it was called previously, is one of the leading Java ME Runtime implementations for mobile devices. It's been shipping over the last couple of years in millions of devices, pretty much from every major mobile handset manufacturer. And Oracle is upgrading that to version 2.3. It has a number of new features. For example, support for JSR257, which is the contact list communication API, JSR258, the mobile user interface customization API, JSR293, the location API 2.0, as well as a number of other features, performance improvements, bug fixes and so on.
Roger: And then, finally in our news, last week the JCP elections finished. And we've got some new people that are on the board. Alexi, you covered this in a GlassFish blog, so why don't you give us a little update on that.
Alexi: Well, so, yes. The Aquarium has a nice summary of the results. So, before we get to the results, we had a lot of people commenting on who was running for the election. So, let me just start off by saying that there are actually two executive committees: one for the SE and EE platforms, and the other one for the ME platform. And a lot of people commented about people running for open seats, and for ratified seats, which are people that are proposed by Oracle. So, with those two executive committees, the results are in. And the ratified seats actually go to Apache and Red Hat, which were both proposed by Oracle. And the open seats go to Eclipse and Google. So, I think all four of them actually were already on that executive committee. But, Terrance, you want to probably cover the ME part, which you know better.
Terrance: Yes, right. There were also five seats up for election on the Java ME executive committee, and those were filled by RIM, or Research In Motion, Samsung, TOTVS, which is a Brazilian solutions company, and an individual, Stefano Andreoni.
Roger: So, finishing up our news segment, the upcoming events that we have, Devoxx in Antwerp, Belgium, the week of November 15th. Unfortunately, no seats are available anymore. You can't buy any more tickets for that. The DOAG conference in Nuremburg, Germany, the week of November 15th as well, and Eclipse DemoCamp in Hamburg on November 12th. And then, finishing this up, WJAX, which will be in Munich the same week.
Alexi: And one interesting thing about that is that from what I've heard of Devoxx Conference, it's sold out, and I think that the WJAX Conference is sold out as well.
Roger: Wow. So, let's move into our feature interview, which is with Greg Bollella, who is the Chief Architect for Embedded Java. One of the reasons why we did that this week is that the Java SE Embedded 6U21 release has occurred this week. And so, we thought it would be great to fill in with a feature interview from somebody from the Embedded Java department. And Greg is, of course, a good choice. He's the Chief Architect for Embedded Java. So, let's go into that interview right away.
Terrance: So, I'm here at Java one with Greg Bollella. He is Chief Architect for Embedded Java at Oracle. And I thought we'd just chat a little bit about the announcements and what's new in the embedded space, and introduce you to Greg.
Greg Bollella: Thanks, Terrance. I've been working with Real-Time Java for a decade now or so. We have a good, solid product there, good solid implementation of JSR1. It's being used in very interesting places. Some I can talk about and some I can't.
Terrance: JSR1 is the Real-Time specification for Java, in case people don't know.
Greg: Right, OK. So, we just showed the Audi TTS that drives itself based on Java RTS. We also showed a turnpike whole system that uses lasers to scan vehicles going under the easy pass system, so they get the right size and get the right tool applied to the RFID tag. And recently, I've broadened my area of responsibility to include all of Oracle's embedded Java activities. And when I talk about embedded, I'm referring to it specifically in a way that we're driving forward around this area. It does not include Java Card. It does not include TV and it doesn't include mobile handsets. So, everything else outside of those areas, that has a processor in it and that your mom wouldn't identify as a computer, is what I'm working with.
Terrance: You made an interesting comment the other day at the Keynote, about, I think it was, embedded devices outnumbering mobile phones 1,000 to 1.
Greg: To be clear about that, they're not outnumbering mobile phones. They're outnumbering general purpose processors. So, if you look at the processors we ship over worldwide, the processors that are shipped as part of things that we all call computers, laptop, servers, that kind of thing. And then you compare that to the number of processors shipped in embedded applications. That has a 1,000 to one ratio. Many of those are not even 32 bits still. So, it's not, well, we're going to run part of Java platform on every one of those 1,000. But, the important thing to note is that all of those are running code, and there are a lot of embedded developers out there.

Over the past decade or so, we've been seeing a tremendous increase in the complexity of the software that embedded developers have to produce for new devices. And that's key to why we think the time is really, really right for a modern, high level platform to develop code in the embedded space.

Terrance: Because code development and platform development in the embedded space still is quite primitive, right?
Greg: Compared to our world, yes. It's very primitive. The developers, when an embedded developer gets an idea for a new device, and they think, "Well, what am I going to implement it in?" the answer is usually C or C++. And they're being asked to write very, very large, complex software artifacts, and they're struggling. Embedded developers have grown up using a certain set of tools and thinking a certain set of way. What I'm going to try to do over the next 18 months is to really refocus how Oracle approaches Java for the embedded space. And so, the first step along this way is a project we call Varesano, which is our attempt to try to understand exactly what those embedded developers who are currently using Java, which features and APIs of the Java platform they actually use. And so, we built this tool called Varesano, and basically it will accept a Java program, a JAR file, and the library, and the VM. And it will do some really deep analysis in there, and create a runtime specific to that application.

So, our goal -- and we're not there yet, because it's a fairly new project -- our goal is that when Varesano is done, there's absolutely nothing in the application, the libraries or the VM that isn't used by the application. Then we take, and we take that application, put it on that specific runtime, and run it through its normal QA cycle.

Because we're going to be very aggressive, and ultimately, we're even going to do things like escape analysis on the external effects of the execution of the static initializer. And with escape analysis proves that for this particular object, none of the things that the static initializer creates, the objects or fields, they're not touched, but we're going to rip the static initializer out as well. The application won't ever know it, because we're going to be so aggressive. That's why we actually want to build the library, run the program, and see that we weren't too aggressive.

And then, we're going to do this to lots and lots and lots of embedded programs. We might have a website where developers can submit their JARs. We don't know yet. But the idea is that as we use Varesano on more and more of these embedded applications, we have some very good visualization tools.

In fact, one of the first demos today in the Frontier Keynote, the Gephi stuff, actually we should use that as well. We have our dependency graph, too, but that might be interesting to look at that output with Gephi. Over time, this is going to guide our decisions around what's the right way to position and build Java Runtimes for the embedded developer.

And there's another trend, actually, that's driving the need for higher level platforms in the embedded space. For embedded devices, there's usually this, how much of the function of the device is implemented in software, and how much is implemented in hard?

And sort of in the early days, embedded devices were all electromechanical devices, and everything was in hardware. And as time got on, then they started using some specific logic circuits. But they were still hardware, but it was more like digital logic, but it was all hardwired circuits. And then we went to low level processing devices, and then we went to our general purpose processor, but very, very small. They used to call them microcontrollers, like eight bit microcontrollers.

And then, that's starting to build up. And as this hardware became more and more general purpose, the function of the device, the percentage of it that was exposed to the user, more and more, a higher percentage of that was implemented in the software. Because if you look at it, what about a general purpose computer is implemented in hardware that the user understands or sees? Nothing, right? There's no function. It's all software.

Terrance: The value is all in the software.
Greg: The value is all in the software. And an astounding fact, that was auto company executives now have said publicly that they believe that 70% of the perceived value of a new car is in software and electronics. That's pretty astounding, because cars are really devices. I view them as an embedded device. And they started off, they were all mechanical. And they are actually following that trend. More and more of the features of the car that the people interact with are becoming software-based, rather than hardware-based. Cars will always have wheels, or at least some way of getting above the ground, right? And they're going to be transportation things. But more and more, the development that goes into new vehicles is all around software.

And so, the pressure on those software developers, using the tools they have, is becoming intense. With all that in mind, when the embedded developer, when he or she first thinks about a new device, the thought should be, "OK, what language am I going to program it in?" And Java should be one of those choices.

I mean, there's always going to be some assembler and some devices. There's always going to be some C. But, Java should be a choice. And for the appropriate devices, they can make that choice. And Oracle will have the support and the tools and the products they need to do their job with the utmost level of productivity.

Terrance: So, while we're talking about products and platforms, so, Oracle already has some offerings in the embedded space: products, javac embedded. There are a number of supported platforms, including the long-awaited Linux ARM plus JIT, which the developer community has been wanting for some time. You also made some announcements around modernizing the CDC and CLDC platforms. Maybe you can talk about those for me.
Greg: Sure, sure. Oracle is absolutely 100% committed to modernizing the ME platforms, CDC and CLDC. And we've got a couple of projects ongoing. One of them is called the There was a session at JavaOne, if you, I think it should be available on the web. We're kind of wrapping this all up in what we call And we've had discussions with the JCP executive committee and those discussions will be ongoing, even in a couple of weeks, I think. There are two real themes to this, and one is to bring more commonality in the user experience, or the developer experience, in the two platforms, CDC and CLDC, as well as SE, so to make, from the developer's perspective, the different platforms more seamless in moving between them. Today, if you're on CDC, you know you're on CDC. Sort of look for commonality as deeply as we can.

The other part to the modernization program is to get some of the Java six APIs moved into CDC, and what we can into CLDC. Again, looking for commonality among all three platforms. We're not going to take all of Java 6, but you know. So, we'll be working with an expert group and figuring out what's the appropriate set of APIs to move into this.

Another area where we're pushing very strongly on is what we call Java ME plus Web. So, there are lots of web technologies out there. A lot of web stuff runs in JavaScript. And it's a shame that the two worlds haven't had some sort of interaction at the developer level before now. But OK, so let's move forward.

And so, there's really three ways you can approach this. There's the Java on top model, which is that you're writing Java code and you can access web based resources fairly easily. And that's actually available in one form today, with what we call the Lightweight UI Toolkit. And so, you can be writing a Java program in a MIDlet and you can access XHTML. And I believe that's about it there. So it's somewhat limited.

The next example on that evolution is JSR290, which is, again, writing from Java code, but being able to access a greater level of web resources, XML, the DOM, CSS, blah, blah, blah. So, that's kind of the next step. So, those are the Java on top model.

Then there's the other side of the coin. JavaScript developers should be able to access Java resources on the platform. That's some ongoing work. JSR290 is going to be available next year. The full platform, which we call the blended model, where you can do Java and get the JavaScript or JavaScript and get the Java, or a blending of those two. That's a stay tuned sort of position we're on right now. But that's really our goal.

And so, to make the, again, try to make more seamless the way that programmers write code in these two worlds. It's just give them access to one another. So, from JavaScript, you could use the pen functions on the phone, or the hardware devices, and get right to those. You can create Java objects that represent a contact list and scroll through it, and iterate through that in JavaScript code, and then create a widget and use that to display it.

So, we're pretty excited about that. We think that it's a good step forward. And I think that it's going to make the developer community, especially around mobile handsets, pretty happy.

Terrance: Sounds good. So, we'll look forward to that and stay tuned.
Greg: Right.
Terrance: So, thank you, Greg.
Greg: Thanks, Terrance.
Roger: Terrance, very good interview there. I think the thing to follow up on this is Jacob Lieberman. He has written a blog on the release. So, certainly go to our show notes. Take a look at what he has to say in the blog. But this is a great release in moving forward in the embedded space. And I know the embedded people are really looking forward to it.
Terrance: Greg has been around for a while. He has a lot of experience in the embedded space, and he knows the pain that embedded engineering and embedded software development has to go through. It's a fragmented space. The tools are bad. There are a lot of porting and proprietary tools and proprietary OSs and proprietary platforms involved. And Java is really an ideal solution in many ways.

He talks about software being the large chunk or the majority of the perceived value of an embedded solution. I think you're seeing that increasingly. Today, people and consumers are expecting embedded solutions to not only perform their functions, but to also look well, to be appealing to interact with, to provide rich engaging features and interactivity. And Java already offers a lot of that.

I think what you're going to see going forward, and that's what Greg hinted towards, is Oracle is putting a lot more focus on that moving forward, and realizes that the embedded market is a really key market to play a role in, and to increase investment, and to increase the number of products and projects that are happening there. So, I'm looking forward to that moving forward.

Alexi: So, let me ask you what I think is a simple question here. We're talking about the release of Java six Update 21. Is that the real Java six Update 21, which most developers are used to on the Desktop or on the service side?
Terrance: So, Alexi, you bring up a good question. For somebody who is not involved and follows the javac embedded space, that's absolutely a question that we should talk about. So, javac embedded is designed to be 100% compatible to standard javac and its releases. Javac embedded has a number of optimizations that you need for the embedded space, or that you would like to have for the embedded space.

So, for example, things like reducing the footprint of the release. By removing certain features that you typically don't need in the embedded space, such as the HotSpot Server VM, which is a standard part of javac, you can remove that and you can remove some optional API packages that you don't need. You can remove support for graphics so there's a head list configuration javac embedded.

There are a number of optimizations to the garbage collector to be more tuned with embedded usage. There are optimizations for low memory requirements, low memory situations. And then, there is also a whole set of platforms that are supported for javac embedded, such as MIPS and other targeted embedded OSs that javac embedded supports.

So, a whole number of things where the team has gone and taken a javac release, and optimized and tuned it for the embedded space. And that's why the embedded Java release is updated every once in a while to match the corresponding javac platform.

Roger: And if you actually look at this release, what you find out is that the normal javac release would go for about 70 megabytes. And what we're dealing with here is something that would run in a 32 megabyte space. That's small enough for some systems, and of course, there are even smaller systems that are available. And that's when we go into the Java ME embedded devices, as well. So, it drops down from there.
Dalibor Topic: So, Terrance, as a Linux fan, I'm curious what Linux platforms does javac embedded support in this release.
Terrance: Right. Well, Linux is obviously an important solution in the embedded space. And so, javac for embedded supports three versions of Linux: Linux for ARM, Linux for the Power Architecture in the big-endian version, and Linux on X86. Javac embedded also supports, as I mentioned before, a number of other combinations of operating systems and instruction set architectures. Reference to show notes to the page that talks about all the different systems that are supported.
Roger: All right. Let's turn our attention then to our final segment, which is the "What's Cool?" segment. Alexi, you were at J-Fall, so what was cool about J-Fall?
Alexi: Well, J-Fall was really nice. It's a nice set of folks putting this together. It's the Dutch user, Java user group. And what's amazing about what they've done is that they managed to have over 1,000 people attend the conference. And this is just less than two weeks away from Devoxx, which is really happening, I don't know, less than 100 miles away from there. So, the energy was high, I think. People were really hoping to get a lot out of it, and for the most part did. So, I was very happy to be there, and had a lot of very interesting and energetic discussion.
Roger: Dalibor, did you have anything for "What's Cool?" this week?
Dalibor: Sure. So, last week, I mentioned we had a few open positions in the Java platform group, in the security team, in the core class libraries team, and in the language team. And this week, I did another search and we have another set of open positions, this time in the JVM serviceability area. Those are positions in Burlington, Massachusetts, or in Stockholm, Sweden -- a beautiful city, by the way. And they are all for expert level C, C++ system of programming universe and with debugging skills who help us build better VMs. In addition to that, I've also found out that the NetBeans organization is looking for a software development engineer who will be developing new features for NetBeans IDE and improving various qualities of the products. In both cases, you can find links to the blog posts I made about this in the show notes.

This wasn't the only thing that happened in the JDK space in the last week, of course. It was quite a busy week for JDK7. So, Coleen Phillimore has posted a first patch to review, to use native memory and reference counting to implement symbol table and HotSpot.

And all of this may sound a bit like "Star Trek" gibberish. But the general idea behind this is that one of the, as he says in the email, one of the ongoing projects in the HotSpot is to move the VM internal data structures, known as metadata, out of the Java heap, known as PermGen, into native memory. And this patch is the first step in the greater project. And those of you who have met and made permanent errors would probably appreciate this project.

Then we also had Landon Fuller of the BSD Port fame, who posted a quick status roundup of the port. And you can see the link in the show notes to learn what the community has been up to, with respect to the OpenJDK BSD Port, in particular, on the Mac OS Stem platform.

And finally, last but not least -- and I hope I don't butcher the name - Shuli Andrew Phan has committed to change JDK7 to add support for Transport Layer Security versions 1.1 and 1.2, which happened basically in release and updates since Java six has been released. And since this is one of the features on our JDK7 feature list, please try out the upcoming JDK7 builds and tell us how it works for you.

Roger: OK, Terrance?
Terrance: Yes. So, I've finally had a chance to start playing with the Nokia N900 device. It's an open mobile platform. It runs Linux and Maemo. It's a full-blown Linux computer that happens to also have phone functionality, so we can use it as a mobile phone. But what's really interesting about it is that it's this really nice test bed and a hacker's dream, because you can do all sorts of interesting things with it. So, you can install what's called the Easy Debian package to it, and then it basically looks like a full-blown Debian release. Of course, it's an ARM platform, so you need all the ARM binaries for that. But you can run all sorts of interesting Linux stuff on it, including there's an OpenJDK build. You can run javac embedded for it and various stacks to run Java ME as well, such as using MicroEmulator, which is a third party project build on Phone ME.

It's a really cool device. It's amazing the kind of stuff you can do on a device like that. It has a beautiful screen. It has Firefox as a web browser. So, it's just amazing what they packed into this device, really cool. If you're interested in this kind of thing, then if you can get your hands on it, play with it, it's really fun.

Roger: Sounds like a cool device. So, what's cool for me was our week in New York City. I had a good time. What's good is the conference is, of course, very good. But it was also great to sit down with Terrance and have a snack with your family. That's one of the pleasures that we get every so often, is that we get to meet everybody since we all work remotely. [music]
Roger: Thanks for listening to the third edition of the Java Spotlight Podcast. I'm Roger Brinkley.
Terrance: And I'm Terrance Barr.
Roger: Send your feedback to

Transcript by CastingWords