Thank you very much. My name is Scott Adler. I'm the Java Classes tech lead, and welcome to the Java State of the Union. So this year, We're excited that we have more Java than ever before. I mean, this is more than any other year. So what do I mean by that? We have more releases in the past year than ever before. If you just look, this is a sample of some of the releases we've put out. This is more than we've ever done in one year before, and we'll get into detail later on this.

We've had, of 1.4.2, which is our most recent release, we've had over 2 million downloads of this. And this is not what's bundled on machines. This is people who've gone out and downloaded it through software update or actually gone to our ADC site. So this means that people actually have the latest version of Java on their machine. We also have more features than ever before.

These are just a selection of some of the features that we've added in the past year. Some of the key ones are Java3D and JAI. We have new features in Xcode that you might have seen at the Xcode session earlier, and we have some new APIs we want to talk about.

And we have more compatibility than ever before. Now, this is really important because the key to Java is that you can write once, run anywhere, or that's the promise of Java. And we're trying to make run anywhere as true as possible on Mac OS X. We also have support for legacy applets, and we'll talk more about that.

And we have a lot of Mac OS X features, so not just compatibility across platforms, but compatibility between applications on the Mac and Java applications, and of course, enterprise applications. And we have more performance than ever before. We now are taking advantage of these 64-bit CPUs for you. We also are taking advantage of the GPU.

You've seen a lot of that in the keynote this morning, and we'll talk in some detail about that. And then we have performance-tuned releases. And what I mean by that is that we're taking each of our releases, we're looking at our performance bottlenecks, and we're solving those bottlenecks so that we can move on to new bottlenecks.

So, as I like to tell everyone else, that was the marketing presentation. Now I'm going to take off the whole marketing hat and I'm going to talk a little bit more in depth about what's really going on here because I'm not a marketing person, I'm a tech lead. So, let's look at that. So, more releases. What are we talking about here? We showed these releases before and one of the keys here is that we had JAI and Java3D. Last year we released Panther, which had both 1.3.1 and 1.4 in it.

And then February of this year, we released Java 1.4.2 and that was a milestone for us because we're up to date with what Sun has actually released at that point. So, that was a good time for us. We're actually up to date with Sun and we're still up to date with them.

So, now you're here at the Developers Conference and if you are on ADC looking at the Java downloads, we've actually shipped developer previews of our work on 1.4.2. We've been working hard on 1.4.2 on making it better. Today you got your preview of Tiger, and tonight you'll also be able to download an Enterprise preview of One5, and we'll talk about what that means.

Now before we dive into 1.5, we're going to be releasing a final release of 1.4. That's in the future. I'm not going to say exactly when, but that's in the future. We're hopefully going to get lots of feedback from you of our developer preview and then roll that feedback into it and put out our final release of 1.4.2 update 1.

But this update is actually a very significant update. We've been working on a lot of new features, and I want to show a little bit about some of the performance gains we've had in 1.4.2. So with that, I'd like to bring up Caroline to show a demo of 1.4.2 update 1.

So this demo is just a quick preview of some of the performance improvements that we've made in 1.4.2 Update 1. We're going to talk a lot more in detail about the graphics performance improvements on Friday at the Java 2D/3D graphics session, so you should all stick around for that. But if you'd bring up the PC, please.

So you can see here the Java 2D demo running on a dual Xeon 2.8 GHz PC. And this is running under 1.4.2. You've all probably seen the Java 2D demo before. It's a standard demo that Sun ships with the JDK and that Apple ships with the developer examples.

So the important point to notice is that the performance readout is around 100 frames per second. All right, so now if we skip to demo two, you can see what this looks like—oh no, wrong one. You can see what this—ah, wrong one again. Demo 2? Yeah, this is the other machine, please.

So I need to set this up to onscreen, because that's where we've made our improvements. So, you can see the Java 2D demo running on 1.4.2 update 1 has about twice the performance of a PC. And this is a dual 2 gigahertz machine running 1.4.2 update 1. And you can see this for yourself if you get the developer preview 3, which is now available on the ADC site. So with that, I'll hand it back to Scott. Thank you.

So there was a lot of work going on here in our graphic state management and removing a lot of bottlenecks to get this performance. So we can go back to the slides. So if we go back to the timeline, 1.4.2 Update 1 is going to be a major release for us in terms of performance and compatibility. But if we go forward into the future, the future of Mac OS X is Mac OS X Tiger. Now, there's also another release coming out, Java 1.5, which has also been codenamed Tiger. So we just like to play on this, and we'll just call it Tiger on Tiger.

So Java 1.5, we're going to release a version that will run on your Tiger seed. So let's talk a little bit about Java 1.5 for Mac OS X. I know a lot of you are eagerly anticipating this. So this is Sun's biggest change to Java. We're releasing a developer preview, and it's targeted towards non-GUI applications. That's enterprise applications, web objects, and JBoss, those kinds of applications. It includes all the source changes from Beta 52.

Our final release of this, when we do release the final version, we're going to be taking all of the 1.4.2.1 improvements that you saw here and we're rolling that into 1.5. So you can count on all those speed improvements being in 1.5 when we do the final release.

So these are just a bunch of the One5 language features. You probably know about these if you've been following Sun's developments. There are a lot of good ones. Generics is what people have been clamoring for, enums and static imports. You can learn more about these at the Maximizing the Virtual Machine talk.

And you can also go to the website and read all about them. And there are a bunch of new framework features in One5. These are just some highlights. And the first two we like to highlight because they're things we innovated on here at Apple. Classes sharing we've had for a long time. And the OpenGL 2D pipeline is something we innovated in One3. And Sun has rolled into One5. And there's a bunch of other features that will, again, be talked about on Tuesday's session.

So now our Mac OS X Tiger, what's important in here for Java developers? The important thing in here is Quartz Extreme. This is one of the most important things. The Quartz Extreme that's going to be in Tiger on the correct configurations is going to be able to accelerate all of your Java 2D drawing.

This is very similar to the stuff we've done in the past, but it's going to be on the OS level, so all your Quartz drawing will be sped up. We also have new enhanced tech support. There's going to be system-wide performance improvements, which again will lead us to detecting what other things might be bottlenecks and fix those. And of course, all of our 1.4.2 update one work that's being shipped on Panther will be moved into Tiger.

And of course, there's a lot more. I'm not going to get into all those. So back to features. When we talk about more features, one of the big places where we always are adding features is inside of Safari and applet support. So what we're trying to be is tightly integrated with Safari as tightly as we can be. So the big thing that we released that everyone's been asking for is live connect. We have live connect support now, with Safari and with Java 1.4.2.

So all those legacy applications with live connect support that people were complaining about before, now work just fine. So we've delivered that in the past year. We're really happy that now you can actually use your live connect things. It's an older technology, and we don't recommend people use it all the time, but if you have applications that use it, you can run it. And also security, we actually store all of our cookies with Safari's cookies. We share cookies with them, and we use the key chain to actually store our certificates.

So some other new features we have. We've got Java 3D and Java Advanced Imaging. Now, these are two key technologies from Sun that we licensed from them, and we've released in December. And you can get them as a free download. They're going to be bundled with Tiger. And you can just download Java 3D directly from our website, NJAI. And Java 3D is really a high-level scene description API.

It's different from OpenGL and some of the other things you might know of. It's for high-level scenes, so if you just want to describe the scene, let it take care of all the descriptions underneath. Java Advanced Imaging is sort of an image manipulation API that's similar to the kinds of things you can do in Photoshop and similar to some of the stuff we do in Core Image.

So you can do large-scale image manipulation using JAI, and it's all cross-platform. This has been implemented on the other platforms. So you can write something in JAI and Java 3D and bring it to other platforms or take your app from those platforms and bring it back. So one of the key examples of this is and some of the tools used on the Mars Exploration Rover mission.

And so we're lucky enough to have two of the engineers from the Mars Exploration Rover mission here, Jeff Norris and Mark Powell. I'd like to bring them up to show you a little demo. Thank you, Scott. Good evening. We're here to talk a little bit about Maestro, which is the science operations tool for the Mars Exploration Rover mission, written entirely in Java and brought to the Macintosh platform with the help of the Java team at Apple. This tool is the tool we use to analyze data that's received from the rover, Spirit and Opportunity, each day in a scientific framework and then build a high-level activity plan for the rovers to execute on the next Sol or Martian day on Mars.

It's also a public engagement tool that we've distributed to the general public, and all of you, and some of you may have already done it, can download Maestro onto your own computers, onto your own Macintoshes, and use it to follow along with the progress of the mission. We'll switch to demo computer number one.

This is one of the mini-updates we've released for Maestro, which steps users through the progress of the mission. They come back and download data updates from Maestro, which kind of bring them up to date with what's been going on. So we'll start this first update. You can hear a little bit from our mission control as we were coming in for landing on Spirit.

I guess we're not going to hear that. What the software has allowed us to do is to reach out to the public in a fundamentally new way because this is an actual mission operations tool for the first time released to the general public. Now, it was developed primarily for the mission operations workstations that we have at the Mission Operations Center at the Jet Propulsion Laboratory. Okay, this is going to be really loud.

cheering very loudly at the successful arrival of Spirit on Mars. What I was saying was this has allowed us to reach out to people because it's the real thing. It's giving them a hands-on experience with the tool. We developed this tool for the Linux workstations and mission operations, but the Macintosh platform is an important one to us for two reasons.

First, our primary user community, which are the scientists on the mission, use Macintoshes in their daily work for a lot of other purposes, and they wanted to bring this tool onto their primary computers along with their other applications. And also, since we are distributing this tool as an educational tool, the Macintosh platform is critical for the educational market.

So when it was time, well, actually, right after we launched these rovers to Mars, we were thrilled to learn that Apple had released support for Java 3D and Java Advanced Imaging and literally called up these folks at Apple and shipped them the binaries of our application. And we got an email back a couple weeks later saying it works great. It didn't have to change anything, which was really a great relief to us because, believe me, we had other things to be worried about right then.

But literally, we were able to turn right around to our customers and to the public and say this application, which was developed for Linux, primarily for operations, is now available to you all on Macintosh. It really made us look good, so we certainly appreciate that from them. Now I'm going to step through a few of the features of this application just so you can kind of get a feeling for how we use it in operations. I'm going to do this from the point of view of a scientist who's using the tool to understand the Martian environment and plan for another salt on Mars. So.

What you're looking at here is what a scientist might use in order to just get his bearings on Mars. This is the cylindrical projection of images taken by the vehicle. Now, we have a mast on top that takes pictures in different directions. And what we're using here is Java Advanced Imaging to stitch these images together in real time using a component developed at JPL called Jade Display, something else which is freely available to anyone. We also use these Java Advanced Imaging technologies to render other projections of this imaging. of this image, and Mark's going to talk about that.

So here I'm going to bring up what we call an azimuthal mosaic view. This is kind of an overhead image that gives you on one page the entire vista of possibilities that a scientist might want to explore. We might start by saying where our rover is currently here and if we're going to drive five meters today, do we want to travel in this direction to the northwest or this direction to the northeast? And as Jeff was saying, we are rendering all these mosaics in the fly from the source images. This is 20 images being composited together into this mosaic.

And Java Advanced Imaging is a very powerful tool for doing this. We've downlinked upwards of 35,000 images now from both of our rovers on Mars, Spirit, and Opportunity. And the scientists have used this tool in its mission form to view every one of those images for quality control and scientific investigation.

And when they really want to get an immersive sense of where the rover is and what it's doing, we also have this 3D view which is enabled by Java 3D. It really lets you get down through the rover's point of view and take a look at the Martian data. on terrain, up close and personal, from any vantage point that you want.

We're also taking advantage of some of the advanced features in the Java 1.4 VM, including NIO buffers, which is what has enabled us to load what is a very large data set right in front of you right there. I mean, we didn't have that preloaded, so we can load these data sets in just a few seconds, really kind of blowing away all of our hopes in terms of performance.

The other things that we use this tool for is actually constructing plans for the spacecraft to operate on the following sol on Mars. So what we're going to show you now is how a scientist might use Maestro to plan a basic arm sequence, a sequence that uses the rover arm. So what Mark's doing right now is he's building a target.

It's a named position on Mars, and our scientists and engineers on this mission use Maestro to name every single location that's stored on the Martian surface. So if you hear about us talking about a rock called the Pot of Gold quite recently, it's this tool that they're using to name it. What you're looking at now is a simulation, a basic plan that's using the rover to plan a basic arm sequence.

So what we're going to show you now is a simulation of the rover's arm, and as Mark clicks through this simulation, you see Maestro kind of giving you a peek into the future of what the rover's going to accomplish if the plan that's currently on, as it's been built right now, is left that way and sent to the spacecraft.

This is a valuable simulation tool I thought we'd finish up with a few pretty pictures, and you've probably been wondering why you had these red-blue glasses, and you came in the door. So if you put them on with the red side on your left, then you will not get a headache, and see what we're actually trying to show you.

We'll load a couple now, and they'll show some more at the end. But what you're looking at here is the view we had coming out, the rear camera from the Spirit Rover, right after we drove off for the first time, in Gusev Crater to begin exploring Mars. I can't tell you how excited we were to see that looking back. We didn't stay here very long. We drove far away from the spot, but this is the first view we had to confirm that we had safely left the lander.

I think the next thing we might show, what do we got next here? This is going to be Bonneville Crater, a place we got to after about two months of driving on Mars. We've driven a lot further now. We've driven now upwards of two and a half kilometers—sorry, three and a half kilometers—on Mars since the beginning of the mission, much further than we ever expected to drive.

So Mark's going to scroll us across, and as you're scrolling over here, you can see right here, that little white dot there is actually the heat shield of the lander. So as we were coming in on Mars, the heat shield separates from the spacecraft, hit the ground and rolled for a long way, and we found it again while we were driving. Amazingly enough, we found the heat shields for both of the rovers.

It's amazing how something that we made sticks out on this very alien landscape. So that's something we brought with us. So I think we'll be showing some more pretty pictures later, but I'm going to wrap it up with that. Thank the Java team and Apple again, and hand it back over to Scott. Thank you.

So can we go back to slides? So that's really exciting. We were glad that we were able to work with JPL on getting this all working on the Macintosh and that all of our Macintosh users can run Maestro and try it out. We also love the fact that in Mission Control, they had a bunch of PowerBooks there. That's kind of fun. Oh, and this is in case the demo crashed or something. You can see the pretty pictures.

So let's talk a little bit more here. When we're talking about features, Xcode has a lot of new features for Java. We've heard you, we know you want better indexing in Java—that's in 1.5. Better code sense—actually working code sense for Java, which is a new feature in 1.5. And we have some new things with Ant and JUnit and new J2EE support. So check out these other sessions that will talk more in depth about this.

So Shark, I don't know how many people out there know—who knows what is Shark? Oh, that's good. Okay, so the next slide, you can read the beginning, you know what Shark is. Shark is a profiling tool that we use here internally. And the biggest point is that, for you, is that Shark now supports Java profiling.

So not only can you profile your native stuff, you can profile your Java stuff. So please download, take a look at Shark, try it out. There are a couple demos that will be done at the maximizing the Java virtual machine. So this is Rendezvous. I don't know how many of you actually know details about Rendezvous, but Rendezvous is basically a way to discover devices without any configuration. So what we're announcing today is that we have Rendezvous for Java support, which means we've wrapped all the APIs for you. You don't have to do any native code.

You can get directly to that open source implementation just using your 100% Java code. So this is great if you're trying to connect to set-top boxes or printers or something like that. And this will actually be bundled into our Tiger release, so you can count on it there. You can download it now.

So let's go back to compatibility, because compatibility is a key point for us. If we're not compatible, you won't port your applications to the Mac. So write once, run anywhere. This is the promise of Java. A lot of people know that it's more difficult than just that. But what we're doing to try to solve it is we're shipping up-to-date Java with every single box that you buy.

So when you go out and you buy a Mac, it's got Java installed on it. It's not like other platforms where you have to download it or you have to go hunt for it or some other people like HP are now bundling Java on theirs because they know it's a good idea to have it there. People want their applets just to work.

So what does this mean for enterprise? In enterprise, we bundle Mac OS X Server with all of our hardware, and we also include with that JBoss, Apache, Tomcat, WebObjects. So your enterprise applications will work right out of the box with the software you have. You don't have to go out and buy anything. You can just run it right there. And there's a lot of information in this session on JBoss about these details, about how to get your WAR files and other things running on your J2EE servers.

So, Micro Edition. Micro Edition is an interesting thing because obviously we don't have any devices that run Micro Edition, but you can use the Mac to develop for Micro Edition. You can build your midlets right on the Mac in Xcode. You can run a simulator right on the Mac, and you can try it out, and then you can download it right to your phone. So, to show this, I'd like to bring up Ted Jucevic to show us a demo.

So, you know, this really isn't, um... What I'm really trying to show here is actually using Xcode to do AMP builds and stuff like that. But by itself, That can only go so far for excitement. So what we're going to do here is actually show using and David Koehn, and the rest of the team will be joined by Ted Jucevic, who will be and other members of the team.

And what I'm going to do over here is actually just go ahead and build and deploy this to an emulator. I actually have over here X11 up and running. Should just go ahead and build and launch up the emulator. This emulator I actually got from Mike Powers' website, mpowers.net. You can download it and we're actually going to be showing a template.

in 318 on Wednesday morning. So that's pretty exciting. You've got your mid-light up and running. If any debug stuff comes out, it goes back to the terminal. But let's actually just go in here, change something, so that it's obvious it's not just a canned movie or something like that. And asteroids in Xcode, let's go ahead and just change this back to zone. Z-O-N-E, if I can spell correctly.

And let's go ahead and relaunch that and rerun it. And you can see it's not a canned thing. Now, that's great. You get it up and running on the computer and stuff like that. But the real world is where things actually happen. So let's go ahead and just go ahead and deploy this to the cell phone. We have over here, let's see, Cocoa component. And with any luck, we should have the cell phone over there.

And expand it out so it looks a little bit more like a cell phone. Let's go ahead and push this jar over. With MidP 1.0... You don't have to use the JAD file if you're just deploying the JAR file, as long as you don't have any properties in the JAD file that it needs. So we're pushing it over. It says, do you want to accept it? Let me go ahead and say yes.

Push it over. and with any luck it should install and save. And then let's go ahead and run it. So it's pretty easy to do Java deployment to phones from Mac OS X. And if you come to my session Wednesday morning, 3:18, you'll actually see and we'll be demoing a template that will be available after the session. So thank you very much.

"So that shows you can easily develop stuff for your phones right on the Mac. You don't actually have to go out and install another emulator or something like that. It's just right there for you." "Finder running application." So now let's talk about desktop Java, because we spend a lot of time on desktop Java making this a smooth experience for people.

So let's back up again and talk about desktop Java. And applets is one of the biggest use of desktop Java. It's games. It's stock tickers. It's almost anything you can find in an applet. And so we've been working hard on web compatibility. We added a bunch of things into 142 Update 1 that address multithreaded event processing on applets. We also have fixed hundreds of very specific applet bugs. You filed bugs saying this specific applet doesn't work right on the Macs. We fixed those.

Plus, we also updated our whole drawing architecture to handle the old style 1.1 drawing. Now, if you know old style 1.1 applets, they do a lot of things that are not really recommended today, like grabbing graphics from a second thread and just pounding on them instead of calling repaint and updating. So we're handling those cases much more smoothly now. And so that actually means thousands of legacy applets that might have had little quirky problems no longer have those problems because we now are much more compatible when it comes to multithreaded drawing.

And also we have Web Start, which is a great way to keep compatible applications so that you can download full-fledged desktop applications from your browser. And you can have things like custom JNI code inside of those Web Start applications and have different JNI code for different platforms if you need any platform-specific stuff in Web Start.

Now, application compatibility. One of the big things we've done for compatibility in Tiger specifically is that we're going to ship 1.3 with Tiger. Now, the important thing is you should migrate off of 1.3 now. And the reason for this is that we're going to be removing 1.3 from a future OS release. I'll repeat that again.

We're going to be removing 1.3 from a future OS release. So if you're dependent on 1.3 and you have a bug that's stopping you from migrating from 1.3 to 1.4, you need to get us that bug immediately because if it's something that we have to fix, we need to address it right away. So it's very important that, as at all possible, you can move off of 1.3 onto 1.4 because 1.4 and 1.5 are the future of Java.

So let's talk about 142 Update 1, what we have for compatibility. We've talked a little bit about this. Multi-threaded painting is really important for legacy applications, and this means being able to just slam a graphics object from lots of different threads at the same time. We now can handle that really well.

We also manage our own context and surfaces separate from the Cocoa framework, so we're able to not have to worry about when Cocoa does some drawing, we know what our current state is. And that's one of the ways we got that great performance in the first demo you saw of the ball spinning around. And, of course, the repaint mechanism compatibility. So we're now actually much more compatible to all the legacy applications.

So the other thing that we've done is we have lots of Mac OS X enhancements to Java. And these are enhancements that are optional things you can do to try to be a better Mac OS X citizen. And these aren't things you're required to do, but most Mac OS X users are pretty savvy.

And if your application doesn't look—if they don't find the Quit menu where they expect it, if they don't find the Preferences menu where they expect it, they're going to think that you're not a good programmer. They're not going to think, oh, that's fine. They're going to want it to look just like everything else, where it's consistency.

So one of the things we have is we have accessibility. So in accessibility, what you can do with this is you can support the Java accessibility APIs, and then our accessibility frameworks that are built into the OS will just use those Java accessibility APIs. So things like the screen reader for the spoken user interface will just work as long as you support Java accessibility.

We've done all the work to get that middle layer so it all works together. It also lets you do things like scriptable applications. So you can actually support your buttons being scripted for button presses and things. So things like the automator application could work with your application if you have it scriptable.

The other thing is that we've made Aqua everywhere. Now you've probably seen this before, but we just want to mention again, AWT, since it's using Cocoa, has all the Aqua look and feel. Swing, we have the Aqua look and feel, and we've put a lot of effort into the Aqua look and feel to make it look just like native. We actually use native rendering for the swing Aqua look and feel. So your swing lightweight components are actually using the very same rendering path as the Cocoa heavyweight components. So everything looks exactly the same.

Obviously, the swing components are a lot more flexible, but when you have a swing application and you use the swing Aqua look and feel, users should not be able to tell the difference between a native application and your Java application. We also have support for things like brush metal windows and moving the menu bar out of the window and up into the screen menu bar where Mac OS X users expect it.

And then the bundling of applications. This we've been doing for a long time, but it's worth repeating. We allow you to easily bundle your application from jar bundlers, our application to let you do this. And it takes your jar files, all your other support files, and puts it into an application bundle. So you can have just one double clickable application. You don't have to have a jar file with an associated file of a bunch of images or whatever you might have on other platforms with a batch file to run it. I mean, that's crazy.

So we just want you to bundle everything into one application because users just want a double clickable application. They don't want a folder filled with stuff. And, of course, we have native extensions. So one of the things you can do on every platform is you can use JNI and you can get directly to native. So if there's something we haven't bundled already for you, you can write your own JNI layer and then use native code to get right to any of our native services.

So if there's something you saw in the tiger demo that you really like and you see APIs for it, you can go write your own JNI library for that and then just use JNI to call those in and provide a very thin glue layer between those two. And now to show you a little bit about all these different things, I'd like to bring up Matt Drance.

Thanks, Scott. I just can't stay off the stage. Forgive me. So, I think we've already seen commercials for Friday's talk and for Wednesday's talk. And so, I'm here to give you a little preview of what we'll be talking about on Thursday. Like Scott said, we've got a lot of native additions and simple things. Some that you get for free, some that you don't, but are still as easy as free to implement. So, what I've got here is an email client that I downloaded from SourceForge.

And it didn't actually come just like this, but I did a little work to make it as Mac-like as possible. So, it comes up in Aqua, as you can see. You have the screen menu bar up here with all the menu shortcuts as you might expect them to be. And you have the application menu here.

And, you know, I used our EAWT API to hook in the about menu item, the preferences menu item, and the quit menu item. But I don't want to, we don't want to quit just yet. And, you know, it's a Java application, so it has these toolbar items for, say, creating a new message.

That works just fine, and it works fine from the menu, but there's this thing on Mac OS X called the dock, and wouldn't it be great if Java developers could do something with the dock? So I wrote a very simple JNI library to add menu items into the dock. So I go up here, select a new message, and it hooks right into the Java action as expected. Really not very hard. It was about five lines of code, and if I'm in a good mood, I'll release it to you guys. So the other thing I did was this app originally shipped with its own address book.

It makes you enter all your old addresses, all your email addresses, all your friends, and everything like that, and that's kind of useless. So I figured I'd just write a couple more lines of code with the E-A-W-T Cocoa component, and here we have an address book people picker view, which is part of the Cocoa API to address book. And so this is a J frame with a people picker view inside it, and it's tied into our app, and it's not redrawing. Let's try that again.

So we bring up the People Picker view, and here are all our people. And let me send an email to myself. So I double-click this from the address book, and this is actually receiving an event in Cocoa and then calling back up through JNI to the Java code with an email address, which I then put into the email message. Now, this is where the demo falls apart, because I haven't paid Fastmail this month, and they're not letting me use SMTP. So let's pretend I sent the message. Or better yet, I'll send one from my Yahoo account.

And there are plenty of other things the dock can do. You can set the dock icon and, you know, among other things, you can also bounce the dock. So wouldn't it be great if we could get user alerts just like the regular mail application? And there we go. It's bouncing the dock when I have a new email. And it's already read. That's about all I got to say. This doesn't look exactly like the Apple Mail application. I wouldn't necessarily call it a best-of-breed Mac app.

But this is what the application looked like when I downloaded it from SourceForge. So we did pretty good. And if you're interested in seeing how I did all this stuff, we'll be talking about it on Thursday, and you get through it in an hour. I'll take it back to Scott.

So one of the things Matt didn't say is that he really didn't spend much time trying to clean up that app. It's actually a really ugly app, I think, when you look at the images and things. So the things that we're asking people to do are things like don't design your graphics to necessarily match a specific OS. And they had little tiny graphics that look really bad compared to our photorealistic stuff on Mac OS X. So those are the kinds of cross-platform things you have to pay attention to.

So now let's get on to performance. We've been concentrating on performance. Compatibility has been our number one goal. Performance has been our number two goal, because if your applications don't run, it doesn't matter how fast they run. So let's look at performance. So G5. G5 is our big thing that we announced last year, and we've been working really hard to make the G5 Java implementation as fast as possible.

So what we've done for you—and we announced some of this before, but I just want to clarify—is that G5 instructions are automatically put in place for you. So what this means is your code that you've already compiled, your Java code, doesn't need to be recompiled for the G5.

It automatically—our bytecode compiler automatically does that for you. So if you have things that are using longs and doubles, we automatically are going to use that and convert it into full native 64-bit operations. This means that if you used to have four instructions to do an add, now it's only two.

So it'll be a lot faster on the G5. There also are G5-specific optimizations that are just in the system itself. We know things like how fast the bus is and other stuff like that. And the key—I'm just going to say it again—is you don't need to recompile to get these advantages. So your JAR file or your double-clickable application will just be faster.

So to show you a little bit about this, we want to show you the Cymark Composite Index. And this is a benchmark for scientific applications. It does a lot of math and things a lot of times with longs and doubles. And So we want to compare a G4 dual 1.25 GHz machine, and we got 98 was our score. And bigger is better on this. I don't know exactly what 98 means, but 98 was the score. So now when we compare that to a G5 dual 2.5 GHz machine, it would be unfair because it's 2.5 GHz compared to 1.25.

So what we did is we just sort of said, hey, let's just double it because, you know, 1.25 times 2 is 2.5. So that should be pretty close. And then we look at the G5, we get 289 compared to 196. So the important point here is that it's nonlinear improvement.

That's really important because what that means is it means the new architecture of the G5 plus the G5 instructions means that we're getting an extra 47% just for free. It's not just, hey, we're twice as fast, we're going to be twice as good. were more than twice as good.

So let's move on to talk about the GPUs. We have a lot of powerful GPUs. You've seen a lot of the ways they can be used by things like Core Image and some other utilities, and we're going to be using these. So first, I want to show you a little demo. And if I can go to demo two.

So what you're seeing here is a full implementation of Quake 2 written in Java. So this is all of Quake 2 taken from the open source. Some guys out there ported the whole thing to Java, and it's using OpenGL for all the rendering. But as you can see, it's really smooth. It's really good.

It uses the JavaX sound APIs for all the sound. It kind of reminds me of when I used to play a lot of games before working on the Java team. And it's really good. And really, what I wanted to show you this for is just as a teaser for the graphic session on Friday.

This is a program called Jake 2. I just turned the sound down, so it's not bothering you. But it's a program called Jake 2, and they're going to be talking about a lot more at that session about what you can do with OpenGL and what you can do with games on the Mac in Java, which who would have thought you'd be able to do that? So let's go back to slides.

So we are talking about the GPU and you just saw this game running on the Mac and really the reason you can do it is because all this rendering that just is impossible to do in software is working using Joggle. It's also working because our Java is now fast enough to actually compute all the things, all the physics that needs to be computed is being done in real time. So Joggle in case you don't know it is an open source implementation of bindings for OpenGL.

It's freely available through their website and I don't know what that last bullet point is but Java 3D is also another way to use the GPU and we've talked about it in depth but it's also a high level way to get into scene descriptions and doing sort of high level scenes but if you're really writing a game and you want to get into low level stuff Joggle is the way to go and there will be a lot of talk about this in the Friday Java 2D and 3D session.

And, of course, using the GPU is Quartz Extreme on Tiger. This is the biggest way we're using the GPU. And what this means is hardware-accelerated Quartz 2D. So that means your applications will just run faster. We're going to be able to do millions of lines in times that we could only do hundreds of lines or tens. I don't actually have numbers in front of me. But it's so much faster because all that drawing that was happening on the CPU, all that anti-aliasing that was happening on the CPU is now being pushed off to the GPU.

And it just happens automatically for you. So that's the best part of it. You can try some of this out in Tiger, but we're actually going to be working closely with the Quartz team to make sure that we don't have any bottlenecks anymore. Because if you can imagine, we have all of our drawing code, and the bottleneck before was actually drawing the squares and drawing the lines.

Now that's all gone. Now we get to concentrate on everything else that's in there and what might be slow in our part of the code and also for you in your part of the code. Because if the drawing code goes away, then it becomes your image manipulation code or your layout code or something like that. The other key important thing here is that software rendering has gotten faster. One of the things that the Quartz team did is they implemented this hardware acceleration, and they did the exact same thing that I was talking about.

They said, hey, our hardware acceleration is really fast, but our setup time takes forever. What's going on there? And when it was taking 10 seconds to render something and it was only one second for doing your setup, and now it only takes a tenth of a second for your rendering, and it still takes a second for your setup, you're going to optimize that setup. So everything is going to be a little faster because of this.

So we also talked about performance-tuned releases. And what does this mean? It means we're gonna be optimizing each of these releases. So we've talked about 142 Update One and our multi-threaded drawing updates. And this is a big performance increase because before we were having to wait for one thread. We were gonna have to block the main thread of your application to be able to draw. We don't have to do that anymore.

And what does that mean? That means as your application is doing something, interacting with the Cocoa framework, let's say resizing or something like that, we can keep drawing. You can be drawing from another thread, from a Java update thread. So you can be repainting while you're live resizing. Before we had to wait for some of those things. And if you have multiple threads drawing, they're not gonna be contending with each other, especially if they're drawing to separate contexts. So this is a huge performance upgrade.

You also can get intelligent display updates. And what this means is this is what's called in the graphics, in the graphics world as flushing or sinking to the screen. So people over flush. What happens is you over sync to the screen. You're trying to push frames up to the screen at 300 frames a second, 400 frames a second. And that's a waste because your screen is refreshing on an LCD screen, 60 frames a second, on a high end monitor, maybe a hundred frames a second. There's no need to actually push that data up to the screen.

So we've optimized this so that you aren't doing all those extra data pushes. So you're only doing data pushing when you need to. So if you're over pushing, it's only gonna do it when it has to. And this is the same implementation that we've actually received this reference implementation from Sun. So we're not playing any tricks here. We're actually doing the correct thing. 'Cause some people think, oh, you guys are flushing. Is that a trick? No, it's not a trick. It's the way you're supposed to do things.

So 1.4.2 update 1, these are just some benchmarks that I grabbed from the team, and these are just some benchmarks we use internally, and we're getting as much as 50% improvement on just standard benchmarks. And this doesn't just measure our graphics performance like you saw before. This is system-wide performance on some of these things. Swingmark Aqua is the second one there, and that actually involves opening lots of windows and things that graphics really doesn't affect. So there's a lot of things that we've sped up in general. And these are great numbers to see.

And then the other performance tune release is Tiger. So we've talked a little bit about Tiger. One of the big things in Tiger is that we have new Tiger APIs to use for things like the whole tech system is being redone for performance underneath the covers, and we're going to do that for you. So we're going to take care of using the new tech system for you.

Like I said before, Quartz Extreme lets us discover new bottlenecks, so we'll be able to find out what really is slow beyond the graphics drawing. And there's going to be lots more coming in Tiger. We have a while to work on polishing our Tiger release, and so we're just going to be putting a lot more performance things into it.

So one other thing I wanted to talk about—and Steve covered a little bit of this this morning in his keynote—is that we have more developer tools than ever before on Mac OS X. And this is just a sample of some of the tools we have. And there's a lot of people who are going to be here at the conference to talk about this, and I wanted to highlight a couple of them. Eclipse 3.0—how many people here use Eclipse? Okay, great. So I really strongly am encouraging you to go to the Eclipse session.

There are going to be a couple of the key people who work on the Eclipse project there talking about it. It's not just an introduction. They'll be talking a little more in depth. So it's Tuesday at 2 p.m. They're going to be here to talk about it. And I know a lot of people love this whole—love the whole platform of Eclipse, so I definitely encourage you to check it out. Check out their IDE and their whole SWT.

Sun also announced today that Java Studio Creator is available for Mac OS X. How many saw James Gosling demo it earlier? So he demoed it in the enterprise State of the Union. And it's a great IDE. It's based off of NetBeans. It lets you deploy J2EE applications and all these different things. So it's a great tool, and they're doing a whole session on it. It's Tuesday at 10:30, so I strongly encourage you to go check out that session, too.

And Oracle. Oracle released JDeveloper 10G. They're going to be fully supporting it. They have a developer preview available this summer. Their final release is going to be in the fall. This is a big deal to have Oracle 10G on our platform so that you can actually use this for developing applications. And finally, I'd like to bring up Axel from Borland to tell you a little bit about Borland's announcements that happened this morning.

Hi, everyone. Well, we're going to have to do something about that list. The JBuilder, you know, we kind of got to notch it up to the top, right? Okay, so how many people here use JBuilder? Okay, so we have quite a few hands. Well, I've got some great news today, because what Borland just announced is that we're going to be supporting the Mac platform with our Optimize It suite, and that includes a full profiler for Java, which allows you to do memory profiling, CPU profiling.

And if you're familiar with Optimize It out here, well, it's really the industry's best profiling tool for Java. And in addition, of course, we also have a thread debugger and code coverage. If you do a lot of unit testing, you'll find code coverage is quite handy as well.

So we're pretty excited about this. There's a long standing history for us with Apple. We started supporting Apple. We started supporting Apple with JBuilder 6. And then when we got Optimize It, it got a little bit more difficult, because Optimize It actually needs to sync its claws into actually native code in order to do the profiling.

But that's no longer going to be a problem, and we're pretty excited about this, because OS X is just a great platform. I still remember going to one of my first usability sessions at Borland, and the engineer, I just looked at our ID, and I go, wow, this is incredible. Absolutely fantastic. Couldn't believe it.

And I thought, wow, I've got to get the latest build and put it on my laptop. And sure enough, I put it on my laptop, and it doesn't look anything like it. It says, what the heck happened here? Well, the developer was using the Mac OS X for the usability review. So you can imagine, we got quite a bit of fans at Borland. So I hope you all take an opportunity to take a look at what Borland has to offer.

With that, I'm also going to add, what's not on the slides today is the fact that JBuilder 11 will be fully supported on the Mac platform, whether you get JBuilder Foundation, JBuilder Developer, or Enterprise. It'll be easy to install, full installer, and full support for Mac OS X. We have JBoss support in the Enterprise Edition. I know you mentioned JBoss. It's something that you guys deliver as well. So this should be a pretty useful ID for you. I do hope you guys all get it. it a shot. Thank you very much.

Thanks a lot. So there's a lot of IDEs for you to use. I didn't mention all of them. I know a lot of people use Jetbrain's IDEA and people who are using Borland for JBuilder and Optimize it, which it was one of the exciting things when we worked on our 1.4.2 update 1 was I just installed my version of Optimize and a bunch of features that were broken earlier just started working.

And I was really excited that this is a legacy application because it's built on top of IFC, but that's the style of that application and it just worked fine with our new update. So it's really exciting. So with that, I'd like to wrap up and I'd like to bring up Alan Samuel, our Java evangelist.

So I'm going to tell you guys a little bit about sort of our year in review and sort of what I've done from a Java evangelism perspective. So I think it was last summer, James Gosling and I were having lunch one day, and I sort of said, how do I get at, how do I talk to more Java developers than I currently do? And he started telling us about these things called Sun Tech Days, and it's sort of this sort of roving outreach program that Sun does, and it's not just Java, but it was something that Apple could actually sponsor and become a part of. And so I'd say for, I don't know, it's been over a year that we've actually been out on the road.

Matt and Ted, two of our Java engineers and myself, traveled around the world. Some of you may have already actually seen us in some of the other venues. These are just some of the locations we went to. We started right in Microsoft's backyard, which I thought was a great location to start our event.

We went right to Seattle, and the amazing thing was we had this huge Java community there. Some of you may be from Seattle. A huge number of people came and attended our session. We had one session there and spent a lot of time talking with us in the booth.

So it was great to know that there are that many Java developers there. We spent some time in the U.K. All of these events, we actually went out. I mean, a lot of you that are here today. Well, let me ask you this. How many of you in the audience, is this your first time here? All right, let me ask you this. Have any of you seen myself or any of the other Java engineers speak at any of the SunTech days? All right, a couple. All right, that's excellent. So I guess it was working.

Really, the whole idea on this was just to go out and reach out more to the Java community and get those people interested in developing and deploying those applications and those solutions on the platform. So I think it's worked. We'll talk about a couple other locations. Here's a great picture of Ted and I actually in Sao Paulo at Red ATV. Now, actually, I've seen some of our Brazilian counterparts who work for us there. This is an excellent success story sort of for Apple, Java, QuickTime. This is a Brazilian television station that runs their entire studio, including all of their ad placement, using a QuickTime for Java-based system.

So that one of the things that I saw, you can actually, as a commercial provider, let's say I've got a product that I'm advertising, I can watch the real-time statistics of how many people are tuning into my show and actually insert in the middle of that television show with a QuickTime for Java system. So I can sit there in the audience and go, hey, guess what? I've got a lot of people watching.

Let's put the commercial there. I couldn't believe this. This entire television station in Brazil was run using Apple products, using QuickTime for Java. I mean, these guys go so far as I believe they've even got chest-mounted laptops. They were running like iMacs with DV cameras that went and connected back to like a mobile television studio.

And then microwaved it back. Nothing was even going to tape. They were that advanced. And here we were in Brazil. Our biggest event by far was China. And I guess I should have expected this, but all of you that are here today are all registered Apple Developer Connection members, right? We had 500 Java developers like yourself sign up in one day in our booth. It was absolutely incredible. So I think the thing is you've seen a lot of the stuff that's skyrocketing. And I think the thing is you've seen a lot of the stuff that's skyrocketing.

And I want to make one more statement about that because it is going away. We want to give you all of these new features, all this new work that the Java engineering team has done is all going to be on 1.4 and 1.5. And that's how you're going to get all those advantages that you've seen today. So please let us know if there are things that are holding you over from making that conversion to 1.4. That's really important for us.

So I think with that, I'm going to go ahead and wrap it up. Before we leave, I think we've got a slideshow with some more. 3D images. Is that already set to go on demo? Demo 2, I think it is. So if you guys want to. I got to put mine back on too. Check this out. Well, that's pretty cool.

Well again, I wanna thank everybody for coming, and we appreciate your time. - Too much of anything is not good for you, baby. But I don't know about that. There's many times when we've loved, and we've shared love, and made love, and made love, and made love, and made love, and made love.