April 2, 1997
John Gage: Good morning. Well, as you can tell from all the milling around in the back of the room, we have almost twice as many people here this year as we had last year. We expect 10,000. Who would think -10,000 programmers, all in one place? There ought to be a rule against that, like you can't all fly on the same airplane.
When you get to this size, it suddenly makes politicians become aware that something's happening, and we have a proclamation. Let me show you the proclamation. [shows proclamation] This is from the Mayor of San Francisco, who is a JavaTM programmer wannabe. Willie Brown is one of the greatest success stories in California, if not national politics. He learned to work the algorithms of government so well that with a dominant Republican majority in the Assembly he still remained Speaker-for those of you who admire performance of random applets.
Here's a proclamation that says the City of San Francisco is honored to have all of us here, and because we're all here, there'll be a 15% discount at every restaurant. No, it's not true. But, it's true that this week, March 31st to April 6th, has been delcared Java Week in San Francisco. So I hope, as we go around the city during the Java Week...[applause ] that we're going to start identifying ourselves when we go into restaurants as Java people. We're going to spend a very intense three days. Notice it doesn't end Friday at noon as most of these halfway conferences do. We're going to wring every bit of energy out of you by the time this thing is over.
Now let me bring the house lights up for those 5,000 new people that haven't been at a Java conference. Java is important. As Bill Joy said, it's simple. We can all go through the litany of what Java is as a language. It's not the language. It's not the technology. It's the people that create new things using this new freedom. That's the important thing.
I want to ask some questions here first. How many people here and in the big overflow rooms -- I can't see you, so I'll have to have someone report later what the count is -- how many people were at the first JavaOneSM Conference? All right, my quick statistical assessment says about 50-40%, or something like that. That's good. We've doubled, that should make some sense. 100% returnees would be the conclusion from that.
How many people in the last year started a new company or took a new job that's Java related? Now, stand up, all those people that did something new in this last year. [large percent of audience stands ] That's the evidence of the importance of all this. Okay, you can sit down again. Last year I walked around and counted suits versus non-suits. This year we have a little higher suit count. So I won't ask you to stand and identify yourselves.
Let's divide the audience into those that write code and those that sell code. First, those that write code, stand up and stay up for a second. Now all of you that are seated that sell the code, notice who's standing. These are the people you need. Okay, everyone sit down now. Everybody that sells code, stand up; come on sellers, stand up. These are the people going to make the money. Everyone that writes code, notice these people. Find them later on.
One of the reasons we do this is because when people come together as we are for the next three days, you must meet other people. So if you do not speak English as your native language, you might be a little shy. Therefore, all rules of politeness are off at JavaOne. Go bother people. Everybody that's speaking to somebody who does not speak English as their mother language, be a little bit patient and ask them questions so that the communication forms, because the companies and the products are global. You all remember the competition we had last year, where over half the Java applet winners were from outside the United States. If we had this contest again today, there would be a much larger percentage of winners from outside the U.S. We're forming global alliances. That's important.
So the rules are little ones. Go up to somebody, tell them what you're doing, say your name. Our name tags aren't very good because of the glare from the plastic. Get a felt-tip pen, write your name in big letters so people can see who you are. Write your company name. Stick it in the little plastic badge. Don't sit with people you already know. You don't meet new people that way.
All right now, everybody's going to stand up, and it's going to be one of these neo-religious experiences. You're going to turn to your left and turn to your right and introduce yourself. Okay, everybody up. Say hello to the person to your left. Say hello to the person to your right. I can feel it. I can feel the companies forming. I can feel the products building. There's nothing like having good APIs that allow things to be shared. That's the point of all this. Now keep doing this. And you're going to get tired. This is going to be intense. We have until Friday evening. Please try to stick with people in the industry, because this is your chance to meet the people building the future, the most important changes in programming and in electronic commerce.
Now 10,000 are here. 5,000 were here last year. There's also another conference, for those of you that are writing in C++. There's a C++ conference across the way. I just want to remind you of the first C++ conference in 1986. Bjarne Stroustrup asked Bill Joy to come be the keynote speaker. Large audience, C++ conference. And Bill got up and said, `` C++ is too complicated, cannot be made secure, and does not have the proper mechanisms in it to allow fully distributed computing.'' That was the keynote. Bjarne was not amused, and Bill was never invited back.
But we need to talk to the people over at the C and C++ conference, because they are us and we are them. So in some sense, the thousand or 800 or whatever number of people are at the C and C++ conference are part of this conference. Notice the tilt of the balance. And Bill Gates is going to show up over there to give a talk. We don't quite know what he's going to do. He's going to endorse Java and so forth. So we want to help Bill. We want Bill to come over here and to stand on this platform and talk to us about Java.
What we're going to do is give a ribbon-a ribbon for the first person here that nails Bill Gates and conveys the invitation to him to come over here. You have to come back with some fragment of his clothing, something identifiable.
Now the ribbons, for those of you that are new. Here's how ribbons work. Ribbons identify ourselves to ourselves, you know, who really makes this work. You know Bill Joy and Guy Steele and James Gosling and all the group-the people that take their lives and write books about Java that we then use to learn about it are special heroes. So we have special hero badges. So these badges for anyone that's written a book -- an article doesn't count; it's got to be weighty -- will get a ribbon signed by Joy, Gosling, Steele, the whole crew of Java. We're going to give out these ribbons. We'll get them all signed tonight so we can start distributing them maybe this afternoon, maybe tomorrow, probably by late afternoon after the sessions. So that's the author ribbon. Honor your authors. Go up to them. Tell them where the bugs are in their books.
I think we'll have a special ribbon for the heaviest books -there are now some 200 books. Now, counting extra CDs or loading them with lead doesn't count. There's got to be serious page count. This one is 900-and-some-odd pages. So we ought to give it a ribbon and those that make their way through it. No, I'm sorry, it's 1164 pages. So that's a book about Java. We'll weigh them all later to see who wrote the heaviest book and give the award.
Then there's the blood, sweat and tears ribbon. This ribbon is for the person or group that ported the VM to some architecture. AS400 -honor them. They're bringing you new markets. Everyone that wrote a VM and went through all the process of testing it gets a ribbon, and these are serious people who should all get raises and get job offers from other companies that are raiding them. So, we're going to give those out. That's money in the bank, those that have ported the Java VM.
Then the third set of ribbons -- well, we'll have to get a different color -- are for those people that found security bugs in either the VM or in any implementation of the compilers or the language. These are serious people. We'll get a really bright fluorescent ribbon for them, because we have to pound on this language if we're going to build the computing, economic, and business environment for the next 20 years. That's what we're in the process of doing. These are heroes. You have to come up and tell us how you found the bug and where you published it so that everyone else can find out what you did. And the ribbon will, of course, be signed by Joy and by Gosling and the rest who created Java.
Then we'll have a different color ribbon for those that find bugs in ActiveX. It will be a bigger stack of ribbons, I think. Everyone has to have found a legitimate chaos, club style, serious bug in ActiveX- of course, Bill Gates will sign each of those ribbons.
The last set of ribbons will be for those in the press that go over and since I'm really trying to incorporate Microsoft, they have wonderful Java people at Microsoft. Sometimes they win politically, sometimes they don't. We want to strengthen them. We want to have the reporters that are covering all this, we'll have one more ribbon for the reporters that manage to get to Bill Gates, ask him a question about Java. What can you ask him? ``Are your intentions towards Java honorable?'' That's a good one. ``Do you endorse 100% Pure JavaTM?'' Those kinds of questions. You have to get an answer to get a ribbon. Just getting there and asking doesn't count. You'll have to fight your way through the PR people, grab him, and wrestle him to the ground. So that's another ribbon.
So we'll have all these ribbons. Come get them so that you can wear them to be identified: authors, porters, bug finders, and difficult-question-askers. Those are the heroes of the Java Conference. All right, so that's that.
Now everybody should have their program that shows all the sessions. We have three times as many technical sessions this time as last time. You're going to be intensely immersed in the technology. Be sure to ask other people which sessions are good, which ones aren't good. Be sure to tell us where we need to beef things up. What if we've not done a good job in telling you all you need to know about JavaBeansTM? We'd better start doing a better job. So that's what we want-your response. Rip off the page that tells you where you're supposed to be and carry it around. That's the component of keeping yourself straight for the next three days. I think I've covered most of the points I wanted to cover. Do I have anything else I wanted to ask you to do? No, that's enough.
All right, last year I made a prediction. I was wrong. Not far wrong, but I made a prediction that instead of wasting marketing money on junk -well, I shouldn't call it junk-on the mugs, and all the different devices that we give away to people; T-shirts are okay; leather jackets with gigantic coffee cups embroidered on them, don't spend that money. I thought that we should instead spend money on giving you something that runs Java. We came within an inch of giving you the Sieman's Smartcard, first because it's cheap, and secondly it runs portions of the Java VM. We tried. We thought we might give you pilots, little pilots or something that runs the Java VM -- but it was a little expensive. We came very, very close, though.
Let me show you the candidates for what I predict we will give you this next JavaOne. Let's take a look at the video.
[Video plays]
I think the numbers are astronomical; 100 million PCs will ship this year. We're not counting stuff in cars; 50 million cars ship a year. Smartcards that are beginning to put just that kind of an environment inside the car and create brand new avenues. We wouldn't have thought this two and a half years ago. James and I went down to the TED Conference to do the first public demo of Java, and now look at the explosion in interest in every part -- consumer electronics, every embedded device, every API that you're going to go through in great detail in the next three days.
But some things have changed a lot. James became an international hero. Java is better known than Sun MicrosystemsTM. And it's changed James. I was trying to find James, because James is supposed to speak right now-I looked for him but couldn't find him. I'll just call for you now to come out of the audience wherever you are, James. You've been transformed by all this. I hope it's not gone too far.
[Gosling walks to the stage, disguised in a Borg mask, then removes the mask.]
Gosling: Well, hello. I'm James Gosling, and no, I have not been assimilated. Instead, I've been having a whole lot of fun. And I think a whole lot of you have been having fun, too.
I think one of the most entertaining things I've seen over the last year or so out of the whole Java thing was a cartoon that this guy Rick Tenant came out with. [shows slide] If you can't read the legend on the bottom, it says, ``Java is supposed to be dynamic, interactive and animated, but George hasn't moved from this spot since he downloaded it.'' And I don't know. I seem to have run into more than a few Georges. I've sort of felt like George a lot over the last six years, actually it's been a whole lot of fun, and luckily I've been able to write more code the last while, which has been even more fun.
So if you remember at the beginning of last year, I did a demo of this little device called the Star7, which was, in some sense, the research project that started it all. And the last I know, the last Star7 basically died. It actually died that day, as I was giving the demo. For those of you who were here, I was quite amazed that it even functioned at all, because somebody had powered it up before, way too early, and it had real heat problems. It basically melted down on stage.
But it was a lot of fun and it continues to be a lot of fun. And a lot of the interesting ideas that were developed there are now showing up. And one thing I did forget to notice is -- do you like the T-shirt? [Points to the shirt he is wearing] It's much better than the Borg outfit, and I think some of these are going to be falling out of the sky. If one lands on you, please take good care of it. There are only a couple hundred of them. [T-shirts are thrown into the audience.]
Okay, so last year I got up here and one of the things I talked about was the various APIs that we were working on-things like the media classes, the server APIs, some of the enterprise APIs, the management APIs, and all the security stuff that we've been doing.
I think there's a little more extra added entertainment over there. Yes, please have fun this week. We're certainly having fun.
And we feel like we've actually done fairly well. There were some things that didn't show up and some things that did. The sort of things that we've made pretty good progress on are the quality and performance and compatibility of the system and I feel a lot better about it than I did last year. Compatibility is a pretty big issue for us because the whole interoperability story is one of the most attractive things about this to a lot of people. I think this year the biggest weapon we have in making sure that that story holds together is this test suite. We've got about 8,000 test programs in the test suite, and I think it's going to be a lot more effective than the one we were doing with the JDK 1.0 release.
The AWT foundation class, all the GUI tool kit stuff, has made some pretty big steps forward. It's a lot more reliable and solid. One of the hidden things in there is called lightweight components. And lightweight components actually let you build components without native things attached to them. They also allow you to build components that are transparent, and that shows up in some new work that we're doing.
We also did a lot of work in internationalization. If you look at the number of bytes in the JDK, the bulk is actually in internationalization and in conversion tables and all this sort of stuff. It's really been a pretty amazing effort. A lot of the stuff that was put in came from Taligent and IBM. And like many other things, this is really a community effort. It's not just us in the Java organization.
There's a lot of stuff that's happened in security, things like signed applets and the cryptographic APIs. And then there's been the distributed computing stuff, like JDBCTM and RMI, all the CORBA and IDL stuff that we have rolled out in early versions throughout the year, and it finally showed up all integrated together in 1.1. And probably one of the more interesting ones is the JavaBeans API. And this is also in the 1.1 release. I think it's going to be a pretty interesting infrastructure for building components that interoperate, and in particular those that work really well inside builders. [Shows slides]
So this is a completely ridiculous chart of the current JDK class libraries. As you can see, there's a huge amount of stuff in there. This is actually a poster that Addison-Wesley put together. It's really become a rich set of foundation classes, if you will, for writing Java code. It's become quite extensive and I think we're all proud of them. They certainly make life an awful lot easier.
And so in the next year we've got a number of new API initiatives that we're working on. Some of these you've seen announcements for. Some of them are new. For instance, there is this thing called JNDI, the Java Naming and Directory Interface. This is one that Sun and Novell and IBM and several other companies put together to provide a uniform interface to naming services. There's a transaction service API that's being worked on with a number of partners. It's a uniform API for dealing with database transactions that are sort of layered on top of the underlying transaction facilities of the OS.
There's a sound API that's a part of the whole media API. This includes stuff like mixed stereo and MIDI files and the rest of that. There's some advanced imaging APIs that you'll hear about the next few days that have a lot more of the interesting image processing algorithms that people like to play with.
There's a set of APIs that we're working on with Pure Software to do a variety of profiling and tracing operations so that you can actually see what your Java programs are doing, and find out where the time is actually going, and figure out just how many times you're repainting that button. Because sometimes the time gets hidden in things that you just didn't expect, and these tools are really good at pointing out where the dead hippos are lying.
One of the other big pieces is more rich security APIs. Actually, one of the big thrusts in the security work is, in some sense, a resurrection of the stuff that was in the original HotJavaTM browser two years ago. That's the ability to read and write files and to access network hosts under more controlled circumstances, and to allow you to do more than the current extremely restricted applet security model lets you do. While it gives you more access, it also gives you more protection.
Now one of the most interesting APIs being worked on right now, and in an advanced state, is something that the engineering group calls the Swingset. It's really a unified UI framework that builds on top of the AWT 1.1 and incorporates some of the technology from IFC, from Netscape. You can look at it in several different ways. One part of it is a rich set of predefined components. They're buttons and sliders and tree viewers and rich text guys and all the common dialogue boxes, like color choosers, font choosers, file choosers, date choosers, and rich-text objects. There's even a plug-in HTML guy, which, I guess, gets demoed this afternoon.
One of the most interesting things about this, and one of the fairly strong pieces of feedback that we keep getting from developers, is that the flexible look and feel thing that we've been doing all along has been pretty attractive. But the flexible look and feel mechanism that's in the current JDK is one that is relatively rigid in that it was really tuned for swapping the complete look and feel as you go from platform to platform -from Mac to Windows to Solaris to God knows what. A lot of people wanted to tie into the pluggable look and feel architecture, so that people could build their own stuff, build their own components that participated in it, and do it more easily than the peer mechanism that was in there -and, just in general, make the whole thing much more customizable, and give you the ability to simplify all kinds of GUI development by giving you a much richer, pre-defined set of components that all interoperate. By having all these components interoperate, it really helps build an open-component market.
So, like many of the other things we do, this unified UI framework is something we hope provides a clear direction for developers. And the development of this actually was led by Sun, Netscape, and IBM with a lot of participation that we hope gets started from the Java community. We're pretty close to having a first set of review documents and a review release ready to go.
The folks from Netscape and IBM have been invaluable in helping us outdo this. And to describe their role in it, here's Rick Schell from Netscape.
R. Schell: James. Morning, I'm Rick Schell, Senior Vice President and General Manager of the Client and Platform Division at Netscape. We at Netscape don't do software yet for dog collars and watches, but we still think Java is pretty cool. And I'm really pleased to be here today to share an exciting announcement of the Java Foundation classes. I'd like to take a few minutes to explain to you why this is important to us and to you as well.
As an enterprise software vendor, we're leading the third wave of the Internet by delivering open email, publishing, and groupware solutions for intranets and extranets. At Netscape we've created a compelling approach to enterprise software development and deployment, and among the things that we prize in that, or in open architecture based on industry standards such as Java, is a network-centric approach to computing that requires scaleability and performance, manageability, interoperability, security, and distributed computing.
Those things are behind what we call ``crossware, '' which is a new category of on-demand applications that span networks, operating systems, and platforms -- rich enterprise applications that are accessible by employees and customers and partners as well. Our customers have told us repeatedly this is what they want to build. This is what you want to build, those of you who are building enterprise applications.
For us, Java plays a central role in our vision of crossware, because it's standards-based, because it is cross-platform, and because it was designed at its roots with heterogeneous networking in mind, and hence addresses those important issues of scaleability, manageability, security, and cost of ownership in a truly distributed computing environment.
Because of our strong commitment to Java-and I think we're going to ask John for a few of those ribbons because we have a number of people who've done ports... we found a few security bugs in our two years of involvement with Java; we were among the earliest Java licensees; and we've invested substantial resources into building Java-based components included in our client and server software.
Among our efforts in that last year, year and a half, two years, has been a product development aimed at providing a lightweight application framework for enterprise development that's 100% Pure Java and aids in rapid application development. We call that the Internet Foundation Classes.
Our goal with the Internet Foundation Classes has been to accelerate the acceptance of Java by a broader community of application developers. We believe we succeeded in making that goal occur and we've helped expand the Java community as a result. But at this point we realize the evolution of Java experimentation is giving way to serious enterprise development, and we run the risk of fragmenting the industry with profusion of APIs and toolkits. Confusion to developers and customers and vendors is a high price to pay for diversity.
At the same time, we want our customers to have the advantages of all the technology we've developed during this past time period. And by working with JavaSoft, we're creating a single industry standard that combines the best of our prior investments. Together, we're jointly developing the Java Foundation Classes that will build on user-interface technologies from both Sun's AWT and Network's Internet Foundation Classes. The net result is a unified framework for Java development, a clear direction for developers and customers.
We feel so strongly about this that we're contributing both technology and engineers who are going to be working hand-in-hand with JavaSoft developers. We believe the announcement of JFC will mean an even more rapid adoption of Java and fuel the creation of the interesting new class of applications our customers have been demanding.
Contributing to the JFC effort, in addition to Sun and Netscape, is IBM and the broad Java community as well in review and suggestion mode. Already tools vendors are beginning to sign up to support JFC. Today Semantec has agreed to support JFC as soon as possible and provide support in migrating customers from both IFC and earlier versions of AWT to the new JFC framework. We're looking forward to working with them and looking forward to the first brand new JFC-based applications that you all will build.
I mentioned IBM's commitment to the JFC effort. Here to discuss their contributions is Rod Smith, Distinguished Engineer and Chief Java Technologist from IBM's Internet Division. Rod.
Rod Smith: I'm going to take just a minute to talk about IBM's interest. We think it's great for the industry scene, and the convergence of these technologies, and we're very happy on IBM's part to participate in teaming with Netscape and JavaSoft to bring these technologies together.
We think that this coupled with Java on the server, are cornerstones for providing a complete Java programming stack that enables developers from all parts of businesses to bring products and applications to market very quickly. And with that, we have brought a present- a bottle of champagne that Rick and I will keep back stage for James, Rick, and I to crack open and celebrate this and we have some more to talk about later. Thank you.
J. Gosling: Thank you. And I think you guys have a bunch of studs to get a whole bunch of ribbons. Thanks a lot.
So this is sort of a picture of all the different pieces that we have in the current Swingset. It's a lot of standard things that people have come to know and love in UI class sets, things like tree views, and sliders, and font choosers, and all the rest of that. We've actually got a demo, believe it or not, and we can show most of this stuff. This is Miko.
Miko: Howdy. So James, I guess you've been designing a lot more than just T-shirts. I like it.
J. Gosling: Yes, it was fun.
Miko: What I've been seeing as I go to the doors of the people on the Swing Team, who are building the Swingset, are these signs that say ``Do not disturb or enter unless you are part of the Swing Top Secret Project Team, or you need medical attention. Because if you disturb us, you will need medical attention.'' They've been coding day and night, and I believe it's an impressive piece of work that we're here to show for it.
J. Gosling: Actually, one of the things that really made a difference was when Waiters on Wheels got a web site you can order from.
Miko: Let's cut to the demo. If we could just get this screen up on the main screen.
[Miko opens a window on the Solaris desktop. The window (or frame) contains an attatched menu, below the menu there are a row of round image buttons, and below that, a tabbed folder, with folders labeled Easy listening, Classical, Rock, Jazz, and Swing. Below, in the folder area, there is a large image of the word Classical in beautiful italic script. Directly below that image is a ``tree widget'' or tiny folders which show a hierarchical view of the directory. The folders seem to contain pieces of music.]
What we have here is an example of some of the widgets that were described in that slide. What you can see if you've got your classic tab folder [Miko clicks the tab labeled Swing]...and there's Duke and he's on the swing...What I want to draw attention to is that you've got a lot of nice little tab folder capabilities [Clicking the various tabs-each one seems to show a picture representing the appropriate music category, e.g. Classical, Rock, Easy Listening ...]This is a tree [indicating the hierarchical folders area below the images]. And, of course, an especially interesting feature is that you can place arbitrary types embedded inside of any of these things [ indicating that some of the folders contain images of tiny Compact Discs and even album covers].
J. Gosling: So there are those tree views with objects other than just text inside them. And if Miko can pull down a menu from the top there, you can see there are menus with images in them, and there's this whole toolbar at the top that's got pretty arbitrary objects in it.
Miko: Absolutely. If you look at the menu, for example, you can see arbitrary objects appearing here, including this person's face [Miko pulls down a menu with a text choice ``Dad '' and a choice of a tiny picture of a person's face ]. Other things you might notice that are really interesting, are things like taking this [indicating tree view folder], and embedding music in here [indicating a picture of an album-upon clicking the album cover, the music starts playing]...and, of course, this is a tear-off and you can lock it back in as well. [Miko clicks and drags on the round buttons and tears them off and locks them back on again.]
So another thing to notice is that when you click here, you have a user's configuration, and you can select a completely different look and feel. [Miko selects a menu option that switches the look and feel of the window from a Windows appearance to a Macintosh appearance. Then by selecting a different choice, a customized look and feel appears that includes a scroll bar that looks like a bright red asparagus spear and tabbed folders that look like guitar picks and funky shaded buttons that look like they were taken from a Kai Krause demo.]
J. Gosling: One of the things we wanted to be able to do was switch the look and feel back and forth between things like the Mac and the PC. But you can also design your own look and feel, and this is, in a way a license to be completely tasteless. And in some sense, we were trying especially hard to be a little strange with some of these. This is a rock'n roll look and feel with bull heads on the scroll bars, and guitar picks, and random other artware. You can see how it can switch back and forth between different looks and feels.
One of the important pieces in the architecture is the separation of concerns between the application developer and the UI developer, so that the application developer doesn't have to be concerned with a lot of the stuff that goes on in the actual look and feel, and yet it gives developers the ability to project the kind of look that they want to project. In a sense, the look of your application is the face of your company. It's the way people see you. So the more control you have over that, the more you can do plastic reconstructive surgery on your face.
Miko: Great.
J. Gosling: So thanks, Miko.
Miko: You bet.
J. Gosling: There are a whole bunch of other things we've been working to roll out over the next year. One of these is a new performance runtime for Windows. It's based on JDK 1.1. We're incorporating the JIT compiler from Symantec and we're going to be releasing that as a DLL rather than as an EXE file. This is really intended for ISVs and end users who want to take this, and attach it to other existing applications in a much more clean way. We hope to have this out in June.
Then there's also this thing called the Java PC, or Project Rescue, or whatever. It's really sort of a low-cost way of taking an existing PC that doesn't have quite enough oomph in it to run a modern operating system, and instead run a version of JavaOSTM as a web browser, and turn this PC into something that you can use to search the Web and to run applets. That should be out in the fall some time.
[Shows Addison-Wesley slide with stacks of class libraries ]
So remember this picture with all these classes? There's certainly a community that looks at this set of class libraries and says, ``Oh, this is really cool. There's all this stuff and it's a lot of fun, makes life a lot easier.'' There's also a community that looks at all these classes and says, ``Oh my God, what a lot of stuff there is to try to shoe-horn into a box.'' There are a lot of people in the smaller-end version of the world where size is a really big issue. We've had to deal with this sort of paradoxical problem of having one part of the developer community saying, ``More, more, more,'' and one part of the developer community saying ``No, no, please slow down; keep it small and keep it simple.''
What we've decided to do is come up with a set of different API profiles. One of them is something we're calling Personal Java. It's a new Java application environment that's tailored for small network products. One way to think of this is the 1.1 with the functionality of 1.0.2, and the API limited to that. It's the things that appear to be useful in consumer products. If you look at what's in the full JAE, a lot of it is enterprise-level stuff that most people at home are not going to want to do. People in the enterprise want to be able to talk to Sybase databases, and Oracle databases, but I don't think my mom's toaster wants to do that. There's no point in having stuff like JDBC in there. It's really designed to work on these smaller, two megabyte or less, devices. It's really stripped down, and we've done a lot of work to shrink the memory usage in the actual VM, and various things to compress class file representation even more.
One of the reasons why people often use Java code in small devices is because the byte codes take up less space than actual instructions, so they can get more code in the same amount of ROM. We've been doing a bunch of work to make that even stronger, and we're going to have the specification out pretty soon. We've got a draft specification. We actually have an implementation of the draft specification we'll show in just a second, and we'll have the reference implementation out before the end of the year pretty easily.
So the first set of this is done, and there's one in the middleof the range and that's Personal Java. And the first real example we have of this is WebTV. The folks at WebTV have done a really great job of incorporating Java into their new boxes. This is extending the Java Platform into a very interesting and different space.
I think it's a pretty interesting market for developers that is beyond the normal PC world that they're used to thinking about. The WebTV folks have added a few extensions to deal with television control, but the real thrust is to bring the ability to do interactive content to this nontechnical consumer market, and make it possible for people who are doing web sites to, if they choose, do a certain amount of tuning to the television. It turns out that the box actually does run stock applets off of the Web, but you can, if you want, do a certain amount of tuning for television devices. We have another demo here. Miko can drive this one.
Miko: All right, thanks. There are two reasons why this demo was selected: one of which is that we really want to have you all start thinking outside of the box, because we're all subject -- I know I am -- to ``box hypnosis, '' which is that I spend probably eight hours sitting in front of a PC every day, and just think about the effect of that. I start thinking only in terms of those boxes. Well, there are millions of people, if not billions around the world, who spend six to eight hours a day watching a different box. The second reason is because WebTV is a company that has licensed Java as of Easter Sunday, which is what I call just-in-time licensing.
[On the giant screens in the keynote hall, a huge screen with the WebTV logo comes to life. Upon wiggling the remote control buttons, the screen saver disappears to reveal a screen with spinning, bouncing, exploding, and otherwise animated letters that spell JAVA. Currently, the J is highlighted ] So what you see here is the box itself, WebTV, and we're using these main screens as a TV monitor. What you can see is here is a Java-enabled screen, and this is Java running. I'm going to pick the first option here...Now this is a TV remote control. I'm just driving this box. What you see now is an application-similar to the Star7 demonstration -it's a TV guide. [A TV guide appears and Miko uses the WebTV remote control to select a choice of TV programs.] So I can flip through here and select what I want to watch. It's total couch potato phenomenon -- [flipping through the possibilities that include time, network and a description of the show] Oooh, Star Trek [Miko clicks on the remote and the WebTV picture suddenly has an embedded picture running Star Trek inside of it.] So we can watch TV, but I think we'd rather hear the rest of what James has to say. Thank you.
J. Gosling: Yes, and there's another box that's sitting next to it. I don't know if you can see the television set. It's a Sanyo TV set that's got the JavaOS ported to it, it's able to run applets, and it's going to be getting richer, and a whole lot better over the years. This is to get you all thinking that there are devices other than PCs that matter, that the Web is going beyond the desktop in some pretty interesting ways.
Another fairly interesting direction is the embedded Java that we've been working on, which is Java for even smaller devices, like VCRs, toasters, and so forth. And really what this version of the Java application environment is, one that's tailored for even smaller memory and higher volume products.
And since, in this world, running applets off the Web isn't a big issue-isn't an issue at all -- in fact, it's a negative issue, it's an anti-issue, I don't know -- there isn't this very rigidly proscribed, this-is-what-must-be-in-the-box because developers are expecting such and such. There's actually the ability to configure whatever parts of the JAE you want that are appropriate to the size of the box and to whatever it is that you're doing. And in particular, things like the UI toolkit and networking are completely optional. If you've got a box that isn't connected to anything, there's no point in having all the networking code in there.
Anyway, thanks a lot. I hope you get a lot of information out of the next three days. There are sessions about all this stuff sprinkled throughout the conference. And I hope you can have as much fun as we've been having. This has certainly been a rush for the last year. Thank you.
John Gage: Thanks very much. Now remember what James said. These things have to be simple. They're devices that are expanding far off the desktop; brand new things; never been invented before, now made possible by the small size and the simplicity of what we're building.
For those of you who are in the press are going to be inundated by all these releases about class warfare -- we're into class warfare -- most of you haven't had time to understand much about what's in a class, or what's in the Foundation class libraries. You saw the people stand up that write code. Grab any one of them. Ask them for five minutes to explain to you how someone with taste, someone that has to write code sitting in front of a screen for more than eight hours a day, how someone judges what can be incorporated into an environment that lets new things be created rapidly, that will work on all platforms, that are safe, and that reach this enormous extent James just hinted at, this new world where Java brings all of us into new objects the world has not yet seen.
It has to be done in a way that is ubiquitous. So let's take a look at what the pure idea, the 100% pure idea is. Who here thinks we should deviate from something that gives us ubiquity? Let's take a look at a video.
[Video plays]
Ladies and gentlemen, please welcome the President of JavaSoft, Alan Baratz.
Alan Baratz: Good morning. Thank you all. Thank you all first of all for making Java the success that it is today, because it's only with your continued support in embracing the platform, using it to develop applications, that Java will continue to gain momentum in the marketplace.
And I'd also like to thank you for taking time out of what I know are very hectic schedules to spend the next three days here with us, to get information on Java, to allow us to challenge one another with our ideas, for hopefully we can all learn, and as James said, have some fun, because that's an important part of what it's all about for us.
In addition, I'd just like to take a minute to thank all of our sponsors who have helped support this event, and in particular to thank our Gold sponsors: Apple, Corel, Fujitsu, IBM, Lucent Technologies, Mitsubishi, Netscape, Novell, Oracle, and Silicon Graphics for their support, which has been tremendous.
Finally, I'd like to thank James for that very insightful and enjoyable presentation. But I have to tell you, it seems like James gets all the good stuff. I mean, he got to come up in that Borg thing. He got some great demos, and he even got the champagne. I don't get it. I'm going to have to figure out who puts on this event and have a chat with them for next year.
I do, though, want to reinforce the announcement around the Java Foundation Classes, and the support from Netscape and IBM and the rest of the industry. What this means is that we are all saying to you there is one answer, one answer for foundation classes on the Java Platform. It's the Java Foundation Classes.
Well you know, watching James do the Borg thing reminded me of another movie, Independence Day. Now I'm not going where you think I'm going with this. I saw the movie a little over a year ago, and ever since I saw the movie, I've been wondering, how did Jeff Goldblum get that virus to run on the alien computer. Now at first I thought, well, it was probably a Java applet, because Java's Write Once, Run AnywhereTM. And I assume that means it will run on alien computers as well.
But then the astute of us understand that Java is a safe programming environment. It's a sandbox environment. It can't interact with or corrupt your local environment. So we couldn't have introduced the virus through a Java applet. So then I thought okay, it must have been active...or Brand X. You could certainly introduce the virus that way. But the problem is that using Brand X would require porting and recompilation. Now, I know that sometimes when you all have to do porting, it feels like you're working with alien computers, but I guess that's why Jeff Goldblum looks so tired the morning after coming up with the idea.
Anyway, it's time to get down to business, and what I thought I'd do is start with what the world would look like if computer makers made cars. You'd have Sun cars that ran on Sun gasoline. You would have Apple cars that ran on Apple gasoline. You'd have Microsoft cars that ran on Microsoft gasoline. But fortunately for all of us, that's not the way the automotive industry evolved. You can go out and buy any car and it will run on gasoline that you can purchase from any gas station.
Well, that's what Java is all about. Java is all about the universal fuel for computing. It's all about allowing you to write applications once that will run on any operating system or any microprocessor. But Java is also about being the only platform that allows you to practice safe computing. And now we have a souvenir if you reach under your chair... no, but this is what the value proposition for Java is all about. The universal fuel for computing and the only way, the guaranteed way, to practice safe computing.
There's a lot of momentum that has built around Java over the course of the last year and a half or so since it was first introduced. First of all, we're now estimating that there are over 400,000 serious Java developers, up from about 200,000 six months or so ago. This is in some sense verified by the fact that we put out the JDK 1.1, the newest version of the Java Platform, just a little over a month ago, and through the month of March there were over 300,000 downloads. Now you all know this is not a game, this is not a toy. You don't download the JDK just for fun. You download it if you're serious about it. And so 300,000 downloads of the JDK is pretty good evidence that we are in the 400,000+ range for serious Java developers.
In addition, Forrester has just written a report where they estimate that over 60% of 5,000+ employee businesses are doing development in Java. And they say that over 40% of those 5,000+ employee enterprises will adopt Java as strategic over the course of the coming year. The number of Web pages with Java continues to double every six months. There are over 160 universities that now teach Java programming, many teaching it as their introductory programming course, and over 150 books in print on the Java language, well more than on C++.
What I have here is a graph from IDC that shows growth in the number of Java developers [shows slide]: developers in corporate IS organizations in red, developers in independent software vendor companies in light blue, and then total Java developers in the dark blue. You can see the growth from '96 to '97 being 200,000 to 600,000, and growing into the million range very rapidly. That's your community.
Why? Why is there so much momentum? Well you probably know it even better than I do, but we think it's for two key reasons. First of all, Java delivers value within the enterprise, and second, Java delivers value for developers and software vendors. Within the enterprise, CSX, a large $10-billion rail shipping company, has developed a Java application for order entry and tracking, a business-critical application that's deployed in their enterprise today. But what's most exciting about this is that CSX is making that application available to their customers, so that their customers can access their IS system to place orders and track the shipment of their orders. This is the beginnings of true supply-chain integration, the ability for enterprises to integrate their IS systems and their processes. Enormous productivity gains for businesses will result from this.
And CSX is not the only company doing it. Federal Express is doing it; Heineken is doing it; the Good Guys are doing it; Chrysler has a Java application that they're deploying to all their dealerships to configure orders, to get quotes on orders, to place orders. Java has become very real over the course of the last year, running significant business operations.
And let's not forget Java improves productivity. We said it last year. It continues to be a theme that we hear back from you: improving productivity two to ten times and reducing costs-you still don't need to port.
And then we, along with all our partners in the industry, have continued to deliver on the promises that we made. Last year at JavaOne we told you that we were going to transform Java from a language into a complete programming platform. The fact that we are now seeing not just applets but serious business applications written in Java is great evidence to that fact. We told you that we were going to deliver a component architecture: JavaBeans. We did it, and we did it six months ahead of schedule.
We heard from you that it was important that we ensure Write Once, Run Anywhere on an ongoing basis. To that effect, we did two things. The first thing we did was to significantly enhance the compatibility tests for the Java VM, so that all of our licensees on 1.1 now have to pass over 8,500 compatibility tests before they can ship products with the 1.1 platform. Then we introduced the 100% Pure Java program, to help developers understand how to write applications that will run on all of those compatible VMs. We set up a certification process, and in fact we've announced today that Key Labs is the independent entity that is going to run the 100% Pure certification process for us.
Beyond that, we're also very proud to say that the first three applications have run through the beta certification process to be certified as 100% Pure Java. They are: IBM Host on Demand, a 3270 emulator; the Corel Office Personal Productivity Suite client side has been certified as 100% Pure Java; and we are now starting to run the process for certifying the server side. And then Oracle Web Forms, a form-based database development tool, is the first to be certified as 100% Pure on JDK 1.1, and I think we should give a round of applause to all those folks.
What I want to do is take a break now and have a conversation with Miko who's going to show us a JavaBeans demo.
Miko: If any of you remember from last year -I know some of you raised your hand that you were here last year-I showed a way to take components and wire them together. I made a little dog run forwards and backwards. That was kind of cute -but what I'm going to show you today is a component architecture that is here and very serious.
So, without any further ado, let's cut to this screen over here. And I'll launch what they call the BeanBox. BeanBox is a place, or a home that's inside the JDK that you can download yourself. It's a place where we can install and house Beans, and put them together. So here's what we have.
I'm going to draw an application for you. I'm just going to click over here...And drop something...a little window... I'm just drawing a little window. I'll make it yeabig. And then I'll drop a little button. Now let me show you how this works. What you can do is tell this button that when an action is performed, that you want this button to talk to this one. And what do you want to do? We're going to have it do a mysterious function called Apply Defaults. And bang, it's done. So let me show you what might happen...I'm going to set one of the defaults and then all I need to do is press this button. Now I read a web page that on Hot Wired, which is where I used to work, that said that it was possible to build a browser in 130 lines of code. What's interesting is the ability to build a browser with zero lines of code. What I've just done is visited www.miko.com, and this is a web browser.
Alan Baratz: Miko, what we have here is an HTML-rendering JavaBean.
Miko: Yes. And in fact, what I'd like to describe for you is how this demo came to be. Basically, what happened was on Friday of last week, Fran, my friend at JavaSoft, said, ``Hey, you've got to see this demo.'' Pulls up applet viewer; it's running there. Now, Jere McDevitt, an engineer over in Atlanta who's working on this project, worked all weekend, and on Easter Sunday had this in a BeanBox. He carried it to JavaOne on a floppy disk. This Bean, the browser, is a little bit over 300K.
Alan Baratz: This Bean could also be used in any application that you might want to build that required HTML-rendering capability. You used it to build a browser.
Miko: Absolutely. I used it to build a browser, but this Bean is a fully interoperable component that can go anywhere that JavaBeans can go, including inside of your Excel spreadsheet, anywhere where JavaBeans plays. Let me show you a way....
Audience: Jere!
Miko: Jere. Right. So let me show you something on this screen, which is another interesting demonstration, if we could just get this to come up on the main screen here. Now what we've got here is another demo that was put together last night. And this is....
Alan Baratz: (jokingly) Miko, you're giving us a bad name here.
Miko: [Miko opens the Super Mojo application from the Win95 desktop] This is put together by Win Pham, the CTO of Penumbra Software. What we wanted to show is interoperability. And this is what we've got. What's interesting about this super-MOJO environment is that it's completely Java. This build tool is in Java. What I'm going to show you is that I can take a component here, put it on the screen, and now it's a timer component. [Miko drags a component from the tool bar over to the design screen. ] I'm going to use the MOJO Visual Script language to take this component, it's called the Count Down component, and add a script to it. I'm going to say on timed event [typing the name of the script] What do I want it to do? [Miko opens the script window and drags and drops three events into the newly titled script called TimedEvent] I want it to stop the time; I want it to reset the timer; and I want it to fire an action event.
So now what do I do? Well, I'm done. I can go to the MOJO coder and say, ``Make Bean,''... I'm going to make a Bean called Count Down, Count Down.JAR. I'm just going to save this JAR file, so what happens is that a timer counts down and when it reaches zero, it triggers an action. So now what I'm going to do is load this into the BeanBox. Where did it go? Here it is, Count Down.JAR. I load it in the BeanBox and drop this here. Now we have this timer. [a timer that fires events]
What I'm going to do now is take this button and make the button start the timer. So the action of the button is connected to the timer. [Miko connects the button to the timer.] And I'm going to tell it to start the timer. [Miko selects the startTimer method as the action that the button triggers.] Now what I'm going to do is take the timer and I'm going to make the timer trigger an action -- now remember, when the timer reaches zero, it triggers an action. What I want to do is apply defaults. [When the action is triggered, the applyDefaults method is set to be called.] You'll see in a moment what this does.
I'm going to go to a different start page. What happens when I start is the timer starts to count down. Okay. It didn't like that Web page. Let's try a different Web page. Let's try my home page again. [ Miko accidentally types a bad URL and then tries a properly formatted URL and it comes up on the screen.]
Great. So when I press the start button, it should start the timer and then when it gets to zero, it will actually hit and come back to this page again. So let me show you how this works. I'm surfing. [Miko goes to a different web site.] Now the timer is counting down. This kind of application would be useful in a museum, or a kiosk, or an airport, for example. You give people a chance to use this device, then the user only has 30 seconds or a minute, or however long you want to set the surf time. And they can surf wherever they want, to whatever web sites they want on the Internet, and when this timer gets to zero, it's going to bang back to the home page, like so. [The newly designed ``browser'' has a 30 second countdown timer on it, and after the 30 seconds counts to, the browser goes back to the home page.]
Alan Baratz: Great. I guess it gives new meaning to the words ``configuring your browser.''
Miko: But wait, there's more. What I want to show you now is yet another JavaBean builder environment, and a very exciting one. I'm going to be opening and creating a project that's much more business related than the first browser I showed you.
The way you do it is to go into the designer in J Builder [ Miko opens an entirely different Bean Builder tool], which is a Borland product. What I can show you is how to design a multi-component 401K planner. Now what's interesting about this is that it has components from AWT, which is JavaSoft. All of these components come from Borland. You have these components from Zero G Software, and from Rogue Wave Software, who are responsible for this chart.
Now what I want to do is take a Zero G slider, and I drop it in here. I have the slider. [Dragging and dropping the little slider tool from the menu bar to the design area] If I select the slider, notice that the inspector actually allows you to change these values. [He types different values in for the slider and the slider moves itself, as if by magic .] What you're going to notice is that when I change this value, it dynamically updates the slider. And this is all completely live. What I can do is actually trigger events coming out of the slider. I'm going to type just one line of code that's going to connect the slider to the formula. [ Miko goes into the source coder and enters a line of code, that pretty much glues the value of the slider Bean into the formula Bean that feeds the charting Bean.] Formula on set. Luckily, all of you are Java programmers so you know what this means. [referring to code on screen] So I'm telling it to take the contribution and get it from the slider. Okay, so that should do the trick. When we run the program, it should be able to just connect the slider to this graph. Now notice that the slider is from Zero G and the graph is from Rogue Wave.
Alan Baratz: The graph is another Bean.
Miko: And these are all Beans coming from different vendors, all playing together, interoperating within J Builder.
Alan Baratz: Thanks, Miko. Nice job.
Okay, so that's a quick demo of some of the things that are now possible with the introduction of JavaBeans into the JDK 1.1. That's a bit of a look at the past. What I want to do is switch gears a little, and talk about the future.
1996 was really the year of the client for Java. It was the year in which Java found itself ubiquitously available across a broad range of client devices, and a year in which we started to see the development of a broad base of client side applications, front-ends to business critical applications. 1997 is the year in which we're going to take Java well beyond the client. James has already talked to you about moving Java down to the low end, to personal devices, to embedded controllers to smartcards. I have here the Nokia 9000. I don't know if any of you have ever seen this cell phone. Open it up-full keyboard and display. Nokia is a new licensee. You'll see Java running on these phones.
Smartcards -- you've heard in the past that we licensed Gem Plus and Schlumbergé. We just closed on both. That's 80% of the smartcard market. So moving down, but also moving up. We're moving up from the desktop into the enterprise server environment. One of the things we've announced today is what we call the Java Platform for the enterprise. Let me just take a minute to talk about this.
Today, when you go to write middle-tier applications, you generally end up writing a mass of spaghetti code. [Screen displays slide that includes pictures of a plate of spaghetti on one side and coffee beans on the other] (Now you know the purpose of the picture.) You write code that has business logic mingled with underlying plumbing. You've got to port this to whatever legacy systems, database, and transaction processing you might happen to have in place. It's very difficult code to develop, very difficult code to maintain. Well, with the Java Platform for the enterprise, we're hoping to greatly simplify the task of building enterprise, middle-tier, or server-side applications. And the idea is as follows: First of all, when you go to build your middle-tier application, rather than building it as a homogeneous mass of spaghetti code, you'll build it as a collection of components, a collection of enterprise JavaBeans. Let's take an example.
Suppose I had an application I wanted to build that was all about value transfer, moving value from one place to another. Obviously an application in the banking environment would involve debiting accounts, crediting accounts, and transferring information. Well, with enterprise JavaBeans and the Java Platform for the enterprise, what I could do is build a JavaBean for doing debit; build another Bean for credit; a third Bean for moving value from debit to credit that just calls on the debit and credit Beans.
First, because they're written in Java, all of those Beans will run on any server that you happen to have in your enterprise. But moreover, with the Java Platform for the enterprise, you'll be able to put those Beans on different machines. So you're now building a distributed application. You'll be able to put the debit Bean on one machine, perhaps in one enterprise, a credit Bean on another machine, perhaps even in a different enterprise, and the value transfer Bean on a third machine. And, of course, you need to first make sure that as you execute this transaction- moving value-that it executes with integrity, that you don't execute part of the transaction -- for example, credit -- but not debit. The Java Platform for the enterprise will provide for you that transaction integrity, so you don't have to worry about building that functionality into the Beans. The Beans focus just on the business logic.
Second, because this is in Java and because we've developed Java database connectivity and Java transaction services that allow you to easily access existing database systems and existing transaction processing systems, you can easily use those Beans to access whatever legacy database environment or legacy transaction environment you might have within your enterprise.
With the Java Platform for the enterprise, we're providing the infrastructure within the Java Platform for supporting connection and session management, resource management, distribution of Beans, integrity of transactions, and you focus on the business logic, and writing that business logic as JavaBeans that can easily interoperate in ways that Miko just showed.
So we're very excited about this. This is the cornerstone for moving Java up into the enterprise server environment, and James has already talked about moving Java down into the low-end device environment.
We're also talking today about some new things that we're doing in the safety arena. I've already mentioned that Java is the only way to practice safe computing. It is the only platform that assures you that viruses won't be introduced, that your memory won't be corrupted, that your file system won't be corrupted if you download applets. The way this works is by loading those applets into the Java Virtual Machine. The Java Virtual Machine then becomes, if you like, a safety barrier for managing the access to the local system resources. This is very different from downloading other functionality, whether it be ActiveX controls, or any other software that you might download into your environment, which has full access, full unrestricted access to your memory, to your file system, to your network ports.
However, up until today, there's been some question around the level of functionality that was available from Java applets, particularly with respect to file I/O, network I/O, and applet caching. Well the first thing that we're saying today is that we are opening up the safety model. We are allowing much greater flexibility on I/O. You will now be able to access the file system, access the network, and cache applets and applications, but we are doing it in a fashion that preserves all the sandbox safety characteristics of the Java Platform.
Now, there's been a lot of discussion around the notion of signing applications or signing applets. You have an applet stored on a remote server, sign it, download it, and then it's safe to use it. Signing does not make an applet safe. Signing only lets you know who to go sue when the applet introduces a virus into your system. What we're talking about here is re-employing the notion of signing, but in a different way.
The idea now is that when an applet running inside the VM wants to write to the file system, it asks the VM to write. The VM then ensures that anything written logically is signed by the VM. Now when an applet asks to read, the VM does the read and will only allow the read to occur on data that it previously wrote and signed.
So this is using the notion of signing in a slightly different fashion within the VM itself, ensuring that applets and VMs can't go running around and deleting files, can't go running around and importing arbitrary password files, and corrupting them or sending them out into the network. But at the same time, the applications that you download have a very high level of capability to access the file system. So, for example, a word processor that you download can save the document to the file system. It just signs it when it saves it, and now it's safe to read that back into the word processor.
The idea is that the VM which currently manages safety for Java applets continues to manage safety, managing it for network and file access as well. So the end result in all of this is that there are a few more rows that we need to take a look at. Java will provide file I/O, network I/O, applet caching, but it will not halt your machine, forge checks, or destroy your disk. This is a very important extension to the Java Platform that we've announced today and we'll be rolling out very soon.
James mentioned the Java performance runtime for Windows -the notion of packaging up the JDK 1.1 with a high performance JIT, and delivering a binary freely-yes, freely, zero cost, available for developers or end users, or anybody who wants to use this for building or running Java applications. The notion here is that we want to reduce the cycle time with respect to getting high performance binaries for each new release of the Java Platform out into the marketplace -- instant gratification if you like.
So we are going to be focused on high performance run times for Windows as well as, of course, for Solaris, and we will be working very closely with our other key licensees -- Apple and Novell for example -- to help do the same. Our goal is to get to the point where at the same time we announce a new version of the JDK, we will also be delivering a new high performance, tuned binary runtime. The idea is to work closely with our licensees to help make this happen. In some cases, we'll do the work ourselves.
There's been a lot of conversation around the notion of standardization for Java. Today, we have tried to run a very open, industry-participative process for the evolution of the Java Platform. The way it works is that when there's an idea for a new API, or a new set of APIs for the Java Platform, we attempt to identify those industry players that have unique expertise, or a vested interest in the definition and development of those APIs. We form a working group to define the initial specification. We then make that specification available to all licensees for comment.
Once we've received the comment and made the iterations, we make the specification available to anyone who wants to review it for comment. And once we've addressed those comments, we publish the specification, its freely available, in complete detail, enough detail that anybody could go out and build the libraries to support that specification, and we guarantee that the intellectual property needed to build those libraries will be made fairly available to anybody who wants to do the development. That is the open industry participative process that we've been running to date with respect to the evolution of the Java Platform. And that has taken us a very long way in building a platform that has enormous buy-in within the industry.
However, we understand that at some point it's important to get the standard seal of approval on the technology, if for no other reason than the government is a very large customer, and the government buys only standards. So sooner or later we knew that it would become important to standardize the Java Platform, and we've been in serious discussions with a number of different standardization organizations to try to figure out the best way to do this.
Well, the one thing that I think we all understand is that when it comes to standards, all roads lead to the International Standards Organization (ISO). All roads lead to ISO. The idea is that ISO is the group that ultimately puts the stamp of approval on a worldwide standard. There are working groups now that define the specifications that get submitted to ISO for vote. Sometimes those working groups are ISO working groups, but sometimes they might be ECKEMA working groups, or ANSI working groups or X open working groups, or other working groups, but the idea is there is a working group that defines the spec which ends up being submitted to ISO for a vote. If approved it becomes standard, if not, it is sent back to the working group for more work.
There is a process within ISO for becoming a submitter of publicly available standards. If your process for defining specifications is an open process, if it is an industry participative process, if it results in a specification for which any associated IP is made fairly available to all implementers, then it is possible to apply to ISO to become a submitter of those standards, of those specifications. That is what we have done. We have applied to ISO for the process that we run to be the working group process for the evolution of the Java Platform, which would then allow us to submit the work we've already done, and are doing on an ongoing basis directly to ISO for vote.
In this way, we leverage the work that we are all doing, that we have been doing, and will continue to do, to define, evolve, enhance the Java Platform, and to have a fast path to getting it endorsed by ISO so that it can become a standard. That is the path that we're trying to move down. ISO now has the document, which is our request to become a submitter of publicly available standards. That document is publicly available. It defines the process we've been running. It defines the process we will continue to run. If accepted by ISO, this process will be used to drive forward the standardization of Java. We're also quite excited about this because, as I said, we think it leverages the good work already done, the process already in place, and yet allows us to move through the standardization process quickly.
In addition to all of the technology work that we've been doing and will continue to do, we understand that it is critically important to help you to better do your job, that we need to focus in the coming year and beyond far more heavily, far more aggressively on a rich base of developer programs that include education, training and support, as well as opportunities for co-marketing and co-selling.
What we have done within Sun Microsystems is to restructure the way in which we're going to be delivering developer and software vendor programs to the marketplace, to better leverage all the resources within Sun to help make this a reality. Collectively there will be hundreds of people that will be focused on developer programs for Sun in helping to educate, train and support as well as in helping to co-market. For example, helping to introduce you to channel partners or to end-customer partners, and at the same time we are working with a number of other companies to bring together their training, support and cooperative marketing programs into a very large industry initiative for Java around education, training, support, cooperative marketing, cooperative advertising, and cooperative selling. Collectively, there will be thousands of people, and hundreds of millions of dollars invested in support programs for development.
Specifically, we announced today a new program with Ziff-Davis, a unit of SoftBank, which will include, first of all, a 70% reduction in advertising space for Java advertising. If you've got a product that you want to advertise and it's certified as 100% Pure Java, you can advertise at 30% the cost -- not 30% off -- 30% the cost of what it would normally take in a broad range of publications.
Second, we'll be delivering polybag CD ROMs that can incorporate a broad base of products, and we'll be working with 100% Pure certified application developers to determine what to put in those CD ROMs as we ship them out through the polybags. There will be TV advertising through ZD-TV's daily prime time show, The Site. And there will be a new independent how-to magazine initiated around Java technology and the Java Platform.
So this is just the beginning. You also saw the Java World Tour focused on education and training, jointly sponsored by several different companies, again trying to drive education and training around the world -- just the beginning, thousands of people, hundreds of millions of dollars focused on education, training, support, cooperative advertising, and cooperative selling.
And then there's the Java Roadmap. I'm not going to try to walk through this. We can get copies of this for you if you're interested. This talks about all of the products and new technologies that we've talked about here this morning and have announced today, all rollout over the course of this year. So for example, the Java Foundation Classes, that James, Rick, and Rod talked about earlier today. They will be available in the developer release within the next two months; available, of course, as a part of the next release of the Java Platform, the JDK 1.2 later in the year.
All of the technology, whether it be the Foundation classes, whether it be the performance runtime for Windows, whether it be the new next generation HotSpot Virtual Machine that will give us performance competitive beyond natively compiled C++, all available through the course of this calendar year.
And then we've got the ``Declaration of Independence '' for developers. My parting words: We hold these truths to be self-evident that all developers have the right to open APIs; that all developers have the right to sleep at night rather than port; that all developers have the right and responsibility to practice safe computing; that Java is a much cooler name than Brand X; that developers are endowed with certain inalienable rights, that among these are the right to life, liberty, and an endless supply of caffeine and sugar, and that to secure these rights, developers need only write in 100% Pure Java. Thank you.
John Gage: Thank you, Alan. You know as I watched what Miko did, our well-known, just-in-time Miko, another 10 minutes and he'd have had three more demos that he could show you. It made me think of something that I believe we all ought to keep in mind, that the ideas you saw, what Alan just discussed -- ubiquity, standards, a declaration of rights for programmers -- are ideas that have been held by a lot of people for a long time, and we should honor them.
When we finish here, we'll have a break for half an hour, then this room becomes a session; every other breakout room becomes a session. This afternoon at 3:00 we'll be back in here for an hour and a half, and that's where you hear some voices whose 1960s statements about what the dream was have turned into what Miko just showed you-into reality.
So let me name some names of people who thought of how things could be if everything worked across networks: Ivan Sutherland- inventor of the notion that a computer can allow you to visualize; to draw. James Licklighter, the entire ARPA thrust. Bob Caan, Vince Cerf-they're here-who had the idea in 1960, not to create the Internet, but to create a communicating network that allowed people and intelligent programs to find out things, to communicate, to share, to build new businesses. 1968-Vince Cerf on his hands and knees at UCLA wiring together, putting up the protocols he and Caan had developed. They'll talk about that this afternoon. They then wasted -well, not wasted- they've spent 29 years since then making the Internet work to the point where we can ride on top of it to do what Miko showed you, allowing programs to execute across the Net. It had that Steve Jobs/Alan Kay feel to it. Build something; in this case, it's not inside a single box with a pleasant environment. It's 100 million virtual machines scattered around the Net. Think of that. What's an operating system like in an environment with 100 million, 200 million virtual machines with those safety aspects built in at the bottom? What's that like? That's a new world.
Now as I watched Miko do that simple application with the new tools, I watched the division between those that write code and those that sell code begin to dissolve. Scott McNealy can begin to write code. Larry Ellison can write code. Even Bill Gates can write code. We ought to have a little race. We'll talk about that in a bit.
So the idea that there's something new and very powerful is not really new. The dreams when Doug Englebart 29 years ago, here in San Francisco, six blocks from here, showed big screen, invented the mouse, select-and-drop syntax, created the environment that we've become used to for these last 29 years. You've just seen the change emerging.
For those of you that don't realize quite what the impact of this is -- and I'd say that to the 500 journalists that are here -- all of you that are not journalists, find those with the press pass on, grab them, try to explain a little bit to them: What happens in the next three years when 3-D graphics becomes a thousand times faster and is based on the Java 3-D API. If you've not seen this yet, it's time to look at it. These are major changes coming. The rapidity, the pace of change is what's driven all of us here into this room.
This idea that we have a ``Bill of Rights '' for programmers-I like it. Let's see. If we took the first Amendment, we would say something like, `` A monopoly shall make no law, governments shall make no law that abridges the right of free creation.'' Well, we'll work on the wording, but there's a sense here that brings us all together.
All right, we're ready for technical breakout. Is everybody worked up after this? Is there some feeling that there's a mission ahead? Three days, no rest. Do it, meet everybody, say hello. Don't be shy.
Thanks very much.