Transcript of the James Gosling and Alan Baratz
Opening Keynote Session at JavaOne.
Delivered May 29, 1996 at Moscone Center, San Francisco, California.
James Gosling, Vice President and Sun Fellow, Sun Microsystems, Inc.
Presentation entitled "The Journey."
Dr. Alan Baratz, President, JavaSoft.
Presentation entitled "Java: Opening the Door to the 21st Century."
With opening and closing comments by JavaOne host, John Gage, Director,
Science Office, Sun Microsystems, Inc.
Gage (Host):
Good morning. I brought along some friends, some books that tell us about
the Java Platform(tm). Let me put these down for a second. [sets down a
big stack of books]
There are many more of us here than anyone anticipated, as you can tell
there are almost 5,000 people. Downstairs there are a few thousand more,
and by satellite and multicast, there are many thousands more. Many of you
have been to similar meetings in Tokyo, Singapore, Kuala Lumpur, Seoul,
Moscow, Paris, or Brussels. We've had between 35,000 and 50,000 people come
to Java Days like this to learn about something as technical as a programming
language. I think it's astonishing that we're all here to talk about a programming
language, and to talk about something as rarified as dynamic allocation
versus static allocation. But what we're really here to talk about is writing
programs once that will run on all computers without recompilation.
While you are here today, I want to ask all of you to do something that
will change the way you and your businesses work for the next five to ten
years. Usually, at a meeting like this you'll come into this room, you'll
sit in some place, you'll go out to break, you'll come back and you'll sit
in the same place. Don't do that. Mix it up a bit, because there's a feeling
here today very much like the feeling you have on the first day of school,
when you don't know anybody, but you meet people accidentally who will remain
friends for the rest of your life. Businesses are forming today in the halls,
on sidewalks, or getting coffee. Don't be shy at all. If you have a project
you're working on, talk about it in a loud voice so that someone will overhear
you and ask to join your group. I saw that happen this morning on a street
corner.
The companies that are going to benefit from the technical changes that
Java brings will be the companies formed today, tomorrow, and the next day.
It's very important to meet as many people as you can. Don't be shy. When
we began the Java project, when James Gosling and a small group went to
a small office across from the Stanford Linear Accelerator-first three people,
then five people, then eight people-when that small group talked to other
friends, who talked to other friends, we recruited half the operating system
people from NeXT, the Java Group grew. The discussions about the form of
the language became richer and deeper, yielding what you know now as Java.
These discussions will take concrete form in the next few weeks when Bill
Joy and Guy Steele finish the syntactic definition of Java-the book comes
out in three weeks-and you'll have the 20-chapter description, the final
description of Java 1.0.
I brought these books to show you because some of those people who met each
other casually-here's Patrick Naughton's book, here's Arthur van Hoff, Sami
Shaio, and Orca Starbuck's book-all these people were part of the small
Java crew that drank coffee in Palo Alto and talked about the direction
the language would take. If I stack these up, there are 97 titles, and these
are only the English-language titles.
I want the authors of these books who are here to come up to me some time
during the day. I'll give you a ribbon for your badge that will say "Honored
Author," because you're our voice. You're interpreting the directions
we are taking in a clear way, in language that we can all understand. We're
indebted to all the authors here. I'm going to give you a special ribbon.
And I want to recieve an email from everyone out there who's writing Web-based
books about Java-there's a beautiful one written by a professor in Northern
Japan-Web-based books are giving people a way to learn the language at whatever
level, at whatever speed they feel comfortable. Please send any references
you might have for books and authors in all languages to lisa.friendly@eng.sun.com.
We'll put them up on the Web site.
Since Java has become such a phenomenon so quickly, many of you are more
familiar with Java than with Sun. So here's how Sun works. If you want to
send me email, it's john.gage@eng.sun.com for engineering.
Scott McNealy, the President is scott.mcnealy@sun.com; Bill
Joy is bill.joy@sun.com; and James.Gosling is james.gosling@sun.com.
If there's something that you think we ought to know, please mail us, because
the only way that we continue building, refining, and strengthening this
amazing change in computing, is by listening to everyone here and forming
small conversational circles where we can all learn from each other.
Now let me introduce the person who formed the first small circle. This
came at a time when Sun was building the Solaris(tm) Operating Environment with
15-million lines of C and C++ code; taking forever to get out a new version;
taking forever to fix bugs, proving to us that something new was needed
in computing. So James Gosling took a small group and began this conversation.
How do we learn from Pascal, Modula, Oberon; how do we learn from Self,
Small Talk, Simula; how do we learn from all the language innovations of
the last 20 years and make something new, modern, and simple? How do we
do that?
So with no further discussion, let me introduce the person that began this
discussion and is at the heart of it now, James Gosling.
Gosling:
Hello, thank you and good morning. I'm really amazed to be here. This is
quite a crowd of people. It's much more than I would have ever expected.
And now I'm standing up here, on this "pulpit," I feel as if I
ought to be giving a benediction or something.
For the next 25 minutes, just to set the stage for the rest of today and
to give people a sense of the context, I'm going to talk about the journey
we've been on for the last year, or for me and the people I've been working
with for the last five or six years.
This started a little over five years ago, with a small research group working
in a back corner at Sun-we rented some space on Sand Hill Road, far away
from just about anybody. We set off, in that little corner, to think about
digital systems in everyday things.
We were noticing that in everything, from doorknobs to toasters, there were
CPUs, and these CPUs were starting to get pretty serious. In our work with
Sun, we had a lot of contact with people in various consumer electronics
companies. These people had a very different perspective of the universe,
and they were coming at digital systems from a different direction. So we
built a prototype from that, and went through a number of hoops and grinds.
Then we made the mistake of applying this stuff to the Web, and that's when
life got really, really loony, but it was a lot of fun, and it's been a
lot of fun the last year.
This is a cartoon. It's a little hard to read. It's from the New Yorker,
1981. I clipped it and stuck it on my wall a long time ago. The title at
the top says "Don Z. and his user-friendly apartment." There's
a record player on the little thing on the side there-for those of you who
remember record players-which says, "Say Don, how's about we spin some
platters?" And the lamp is saying, "Don, do you think you could
use a little more light?" The chair is saying, "Don, relax. Take
a load off." I've always had this up on my wall-I mean, originally
it was this kind of lunatic fringe reaction to the Apple Macintosh. But,
it got me thinking-got a lot of people around us thinking-about building
these systems and devices that were intended to be in a person's life where
they're communicating and talking to each other.
One thing that became clear as time went on, was that both data and behavior
needed to be communicated. These devices needed to describe themselves to
each other; not just give a picture, but some sort of behavioral notion
of how they work and how they interoperate. We were gravitating towards
this idea of having little quanta of behavior; little lumps that you could
"squirt" from one piece of the network to another. All of this
was driven by thinking about things in people's homes and what it meant
to build devices for real people.
We talked to people in Japan, at companies like Mitsubishi, and companies
in Europe; we talked to a lot of engineers and marketeers, and the people
who were actually involved in making toasters and elevators and the rest.
Really the issue boiled down to a shuffling of the priority list. In the
computer world, there's one word, "compatibility" that's the lord
of everything. Unfortunately, that turns into almost a tyranny. And in the
world that we were looking at then, there was a bunch of issues that were
more important than compatibility For example, How do you make this thing
safe? How do you make it reliable? How do you deal with the network? Compatibility
is a good thing, but at the level it tended to get practiced, it was anchoring
everybody in the early '70s, which is really where a lot of the technology
in common use today is based.
What we did was build a prototype device and this is it. [speaker holds
up a small device with a display screen] This is what we called a Star7
(known originally as *7), and it's built with "hammer technology."
This is my handy-dandy boot device, also known as a paper clip. Somewhere
in here, there's a boot button-I think I've got it-and with luck, this one
will actually start. This was built about five years ago in 1991. It doesn't
seem to want to start. Let's try the usual solution and rip the power connector
out. Ah, the screen flashed. Anyway, this is a Star7. It was built by hammering
together a lot of different things. There's a TV set here from Sharp. There's
a motherboard in there that's a small SPARCstation system.
I don't know if the camera can zoom in on this thing so that you can see
it? This is where Duke came from. This is the boot screen. You can see the
earth, and there's Duke's hand, and he's "giving the manual" on
how to use this thing, which is sort of "touch it and it goes."
Now we come into the world and here's Duke. This is where Duke originated
by the way, in the Star7.
We have this universe in here where you can "pan around," touch
things, and go into different houses. There were some issues about the little
JPEG decompressors on these things that didn't work really well. This is
a house near where Duke lives and you can see that Duke followed us along.
Here you can navigate into the living room. This is a very "cartoony"
user interface, but remember it was five years ago we did this. A lot of
what we were trying was about different ways of navigation. Here's a TV
Guide. Let's see if we can-whoa, off into hyperspace! We can navigate into
TV shows and look at stuff. We had a lot of fun with this one. We can actually
rip off, and drag and drop TV shows. And when we drop them on Duke, he puts
them in his pocket. I don't know if anybody can see that animation...But
Duke was a lot of fun. Actually we can go into Duke's house. If we press
on Duke and Duke is listening-the touch screen here is a little on the fragile
side-oh come on, you can do it. Ah, here's Duke's house. You can see Duke's
pants and somewhere under there are Duke's hats. If you put the hats and
pants together, you notice that there's actually nothing to Duke. He's just
an outfit.
The goal of the project was to try to build this device. Sticking off the
top of this is a radio antenna. This is a 200-kilobit per second, 900-megahertz
spread spectrum radio. It's also got some PCMCIA cards, some batteries,
and other features. We built a network out of this. The actual device here
was built by Ed Frank, Craig Forrest, and Al Frazier in a pretty "studly"
display of hardware skills.
The Star7 had things in it like speakers from a Nintendo Game Boy and connectors
that came out of a Sony Walkman. We hammered a lot of stuff apart in order
to make it come together. But, we were trying to build-we built-what am
I saying "trying"-we built this distributed operating system that
worked across a large number of devices that could talk to each other. You
could actually pass objects from one machine to another. As we were trying
to build this prototype-we were originally trying to build it out of C++-the
tools kept breaking. It was at a fairly early breaking point when I was
so disgusted that I went to my office and started typing. What became of
this typing was the project called "Oak," named after the thing
outside my window.
One of the things that was really important about Oak in those days, and
about Java today, is that the language was never really an end in itself.
It was something that was built as a tool in order to get a larger job done.
A lot of the things that define what the language is come from the context
in which it was put together. Even though it was just a tool, in a strong
sense, it's taken on a life of its own. Witness this big crowd of people
here. It's certainly out of my hands and has been for a while.
We took a turn through working with the cable television business, and that
was a weird experience. Then the whole Web happened, and that was just an
amazing piece of serendipity, because the things that people were doing
on the Web, and with the Internet, and the whole philosophy of the Web being
this sort of open, crazy, and free-for-all place was exactly the sort of
environment that we had been targeting. Also, the Web was going beyond people
inside corporations, schools, and the small crowd of geeks. There were "real
people" using it. It was really an amazing thing that it matched.
When we tried to throw it onto the Net, we had to change the name because
the lawyers didn't like "Oak," but I think everybody has decided
that "Java" is a much better name.
The language came about as a fusion of four primary different kinds of programming.
There's the object-oriented school from languages like SmallTalk; or one
of my favorites, but mostly forgotten, Simula 67. Then there's numeric programming,
a minor passion of mine, which is difficult in C. One of the things I was
very clear on was making sure that arithmetic was well defined and worked
well inside Java. There was also the systems programming flavor in much
of the style of C.
The thing that distinguishes Java is the approach to distributed programming;
in that there are lots of people who have done cuts on distributed programming
that really look like this computer is an island talking to that computer
as an island, where there's a sort of communication mechanism. But the language
itself, and the underpinnings of it, don't deal with being distributed.
There was also a subtext of trying to build quality software, because when
you're building things for real people, it's really good if it doesn't break.
For many people in the computer world, if it breaks, that's okay, we just
reboot and hobble on. But when it's my mom, it's somewhat different.
We put Java out on the Web about 14 months ago. Then almost exactly a year
ago, we did this formal launch at a Sun event called "Netropolis"
held here in Moscone. Even though it was only one year ago, if you measure
the stress hormones in my body, it feels like seven. There's a saying that
the Internet runs on "dog years." If you look at the engineering
development groups in your average Internet company, it feels like everybody's
on speed, or something that's maybe even legal. This leads to a weird kind
of life. I always thought that the software industry was nuts, but the last
year has been really exceptional. It's also been exceptional in terms of
the press. This is part of "riding the wave" that is the Internet.
We decided to do something on the Internet and got sucked into that maelstrom,
which has been pretty entertaining.
One of my favorites, is this editorial published in the Economist
in October of last year along with this cartoon. It's a little hard to see
on the screen there. Bill Gates is on your left, and he's being dragged
into this web, and there's a spider at the side. Look closely at the spider...[audience
laughs as screen displays cartoon of Gosling's face characterized as a spider]...But
what's really funny is (unfortunately, I didn't have a scanned-in image
of it) that this was in the October issue of the Economist, and in the July
issue of the Economist, the cover showed Bill Gates as a spider, and there
were all these bodies...There was Larry Ellison, and Scott McNealy, and
all these bodies on the cover, all wrapped in spider silk, and he was sucking
the life out of them. And so a few months later, there's... [audience laughs]...I
don't understand...I wish that we at least had done a bank balance swap.
That would have made it more entertaining.
So where is Java today? It's become widely adopted. I don't think that there's
any piece of software on the planet that's ever become this popular, this
fast in the development community. It's really quite astonishing.
There's a set of specifications out on the Web. There's a new specification
written by Bill Joy and Guy Steele who are trying to get it out to the publishers
as soon as possible. This new specification is actually quite intimidating,
because it covers much of the material. But it's interesting when you go
through that spec, and then you look at other specs. Because this is one
of the few places where people have really tried to cover all the corner
cases. You have to deal with all the corner cases if you're going to be
as portable as you really want to be.
Also, people have been moving beyond just doing little applets. We originally
launched Java and the HotJava user interface together. The model was to
have these little applets in pages. But, you could do just about anything
with the base technology itself. And it's been very interesting to watch
people do that.
Then, going along with the very primitive tools that we shipped, is a number
of people who are shipping some much more sophisticated things. There are
people like Symantec and SunSoft that have development environments, and
others like Borland, Metro werks, and Microsoft that have things that are
really close. There are also a lot of people out there on intranets and
the larger Internet who have been applying this as a different cut on client/server
computing where the client is this very loosely structured thing that flows
along the network and lands at the front end where it does its thing, and
the client doesn't have to worry about installing it.
Java has also been spreading to smaller systems and various devices. There
are some folks even working on chips. A lot of the magic underneath all
this is not Java the language, nor the ASCII syntax that people edit with
vi, or emacs; but in the real language underneath, which is called the Java
Virtual Machine. It's the key to platform independence. It's where things
like the machine-independent byte codes live, and it's defined in a machine-independent
way. It's what allows software to be moved around. It's the basis of what
these quanta of behavior are. And it's this piece that's been widely ported
to some huge number of platforms. I have no idea how many.
One of the important things that we did when we first launched Java was
to take the whole source of the system and put it out on our Web site. That
did a number of things. There was the crowd of people who just play- they
just had fun with it. They could have had fun with just the binaries, but
they also like to have fun with the source, because given the kind of people
that are on the Internet, that's sort of what fun is, right? Then there
were the people who were doing marginally useful things, like porting it,
which was very interesting to watch, that is, watching people port it to
lots of different platforms.
But in the end, probably the most important reason for putting the source
out was to allow people to scrutinize it. One of the things that we tried
very hard to do was to have a story about how to build safe and trustworthy
systems. A lot of that depends on how the guts of the thing are built. We've
got huge test suites; last time I asked we had well over 2,000 different
test programs that are applied every time we do a release. A lot of these
are checks on security issues, but you really need to have clever people
out there just staring at it, and having this large community of people
on the Net who have been doing this stuff and discovering that they can
send their bug reports to USA Today. I mean, that says something pretty
weird about the entire experience. We get the bug report, then we fix the
bug, and then we crank a new release. The system tightens up and it's gotten
to the point where the attacks that people can do through Java are much
more like a Mission: Impossible script than something that a real
criminal can do. It's interesting that there are lots of things people do
to share software on the Net. It has absolutely no safety at all and nobody
cares. They just do it. But because we care, it puts us in a somewhat higher
profile.
In terms of where Java is going tomorrow, and that is really what this whole
conference is about, in some sense, is that the language at the core is
mostly going to stay very stable. There are a couple of features that we
may add, and there are a number of issues about cleaning up corner cases
that need to be dealt with. Quality and performance are way up there; as
are fixing security problems. Also very important is adding the ability
to apply signatures to programs that get moved around the Net, so that when
they land some place, instead of being executed inside this "tight
little box," they can actually go outside the box and do things.
But the real action, these days, is in the libraries. The libraries are
the application programming interfaces that people really use. In some sense,
the language is just the glue that holds the bricks together. So, there's
a stack of things that we've been working on, in conjunction with a whole
bunch of people out there.
There's a component API that's designed to deal with interoperability with
things like Olé and OpenDoc. There's a set of enterprise APIs for
doing remote method invocation and remote object manipulation, plus a set
of database APIs. Then there's a set of APIs for dealing with media, such
as sound, video, 2-D and 3-D, VRML, telephony, and time. There's a set of
APIs for security that are above the level of the virtual machine. We're
doing a bunch of stuff under the virtual machine in terms of fixing bugs
in the verifier. We're doing the signing code modules.
But above these, there's a set of APIs for authentication and a set of APIs
for encryption. These have been implemented and done. The technology is
easy. All the issues revolve around the law, just getting the Commerce Department
and the NSA to be happy is where the challenge lies. Yeah, Phil Zimmerman
is not a criminal. I think everybody here needs to write a letter to their
Congressman because the situation is really silly-sad really. There's another
set of APIs to deal with commerce, primarily to deal with financial transactions
so that people can write a piece of software that charges 25¢. There's
a set of APIs for dealing with network administration.
If you look at the overall structure of the Java Platform there's the virtual
machine that insulates all Java programs on the top from all the "goo"
underneath. There are all of these adapters for dealing with different operating
systems and the one that's far off on your right is called the JavaOS(tm), which
is what it takes to run Java on a bare machine.
We have a group of people who are looking at Java beyond the desktop. And
there's a lot of people, outside our group, in various companies who are
also doing this. Some of the devices that people are building are pretty
cool. But, there's been lots of confusion about this in the press. These
things are not going to replace desktop computers. At best, they're going
to be adjuncts, things that give you some connectivity as you roam around,
or visit small places, that can be integrated into the Web. Having different
kinds of screens has some definite implication for authors. This particular
device is a cell phone from Nokia. [woman shown on screen demonstrating
cellular phones] She's holding two of them, one up to her ear, and
if you look at the edge of it, it folds open and is basically an IBM PC
running GeoWorks. But it's a cool little device.
This is my personal winner for the coolness category for hardware. This
is a DRAM chip from Mitsubishi. It's a 60-megabit DRAM. And if you look
in the center of it, this little patch is actually a 67-megahertz RISC CPU.
This whole thing sucks very little power, and is a really fast device. Apparently
the next revision is a 64-megabit DRAM where the CPU is about twice as fast.
So you've got 100 megahertz in something about the form factor of your fingernail.
Once you've got stuff like this, it really changes the type of things you
can build. You could build a complete speech recognition system into a doorknob.
I don't know why you'd want to do that, but you could. I mean, it would
be fun.
But, what it all comes down to is the Internet, which we're all building
together-it's not really a technological artifact, it's not really a bunch
of wires together, and it's not a bunch of businesses-it is really becoming
a society. One of the hard questions is: "What is this society going
to look like?"
This is an article published in the San Francisco Chronicle a while ago,
and it's about this question of what this society is going to look like.
They characterize it in two polls, based on different science fiction genres.
On the one hand is the cyberpunk tradition in the novels of William Gibson.
These tend to be very dark and ominous; they're definitely streets that
you'd feel unsafe walking down. On the other hand, there are people like
David Brin, who wrote a marvelous novel called Earth. One of the things
underlying the novel is the notion of this Net that people use to communicate,
which is a really wide open, free place where people don't feel threatened.
A lot of the thinking behind the original design of the Star7 system from
five years ago was about building a network infrastructure where people
could communicate with each other, even if they were on opposite sides of
the planet. We don't want to keep communication closed within one house
or within one neighborhood; we want the doors opened to the other side of
the planet, to let things in and not be afraid. And that's what we're trying
to do, and I think we're doing a reasonably good job. That's the kind of
thing we're really pushing as we go forward.
So thank you. It's a pleasure to be here. And I'm really glad that you're
here. I hope that over the next few days you all learn a lot from the different
sessions. Thank you.
Gage (Host):
I wanted to make a couple of points. I think James' last comment, "We're
trying to open doors, we're trying to remove barriers," is critical.
Several times he used a phrase that may be unfamiliar to some of you: "hammer
technology."
What is that? It's a simple idea. If you want to build something new, and
it needs special capability, look around at what other people have already
built. If you want to make a new musical instrument that reads the positions
of your hands, and you want something to measure distance, take a Polaroid
camera, take a hammer, smash that barrier, break it into pieces, and take
out the distance sensing element-it's very highly engineered; it's cheap
and you couldn't make it yourself for the price.
So take that approach as you build your new devices. Break down the barriers.
Take these huge operating systems, break the barriers down by taking out
the parts and interchanging them. The fundamental idea is that we're able
to do something that mixes parts that are already functional into your new
ideas.
The second thing that James pointed out is simplicity. When he used the
Star7, did you notice the design criteria, and the enginering dsicipline?
The way it worked was to constrain the design to your finger being the only
control element. He maneuvered through a very complicated space. He animated
that New Yorker 1981 cartoon, which in fact was a distillation of a 1950s
scientific fiction story; he moved through that space with only his finger.
Simplify, and focus that engineering constraint. That's what makes the design
elegant.
The third thing that James did, was put the sources on the Net. For us in
the technical world, this is critical. You have to read what other people
write; you have to comment on it; you have to change it and you have to
fix it. That's the essence of the Internet. When we put the sources on the
Net and everyone could read it, we didn't need a marketing organization.
We didn't need anyone to make brochures or to explain things, because you
could read it for yourselves and make up your own minds. That's a critical
element in this. It's the style of allowing others to share in your creativity.
That's where the power of this lies.
Then what happened? We received thousands of phone calls, even Mike Clary
cannot make 200 phone calls a day. Every organization in the world started
calling because they'd made up their minds by reading for themselves with
no one interpreting for them how this worked. They exercised their good
taste, and said: "This seems interesting." We didn't pay people
to learn. It's the Internet where everyone learns on their own. Everyone
decides on their own. Then when they decide on the right thing to do, they
move. Out of that came the partnership that put JavaOne together. There
are hundreds of companies that are partners, and you're among them. The
person in charge of weaving these relationships together, building the future
for the virtual machine on every device- you'll see a number of them today-is
the President of JavaSoft, Alan Baratz.
Baratz:
Good morning. It's a pleasure for me to be here this morning and to have
the opportunity to speak to all of you for the next 45 minutes or so. What's
so exciting for me about this particular event is that you are the people
who have made the Java(tm) Platform as important as it is today. If it were
not for all the creative and innovative work that you've been engaged in
over the course of the last year, relative to building new applets, new
applications, and new tools, in the Java language, and for the Java environment,
we'd be just another language. It's a thrill for me to be here today to
have the opportunity to meet with you. I'm hoping that I will learn far
more through the course of the next two days from you than I'll actually
be giving to you.
What I'd like to do over the course of the next 45 minutes is spend a little
time talking about where we are, and how we got here, then spend a little
time talking about Sun's strategy relative to Java, as well as some of the
initiatives that we've put in place to help Java achieve its full potential
in the marketplace. I'd like to announce some new products, and new product
directions that will be moving into the marketplace during the coming few
months.
I have to tell you, similar to what James said, that standing up here, I
don't quite feel so much like I'm in a pulpit, but as it's an election year,
I had thought that maybe we should enter a new candidate in the race. What
do you all think of "Duke for President?" One thing is certain,
you know where he stands, you know where he waffles, and you know where
he cartwheels on all the issues. And if nothing else, he sure has the wave
down. Maybe if we're lucky, we'll get him on Larry King Live some time within
the next week.
Perhaps the best way for me to start is by sharing with you a question that
I was asked about two months ago-a fairly interesting question. "Alan,
what do you think of the Internet as an applications platform?" I thought
about it for a minute or two, and then I answered with a question. I said,
"Suppose you had a networked application environment that had the following
three characteristics: First, it interconnected all large businesses, most
medium businesses, almost 10 million homes, and was growing at a rate of
20% to 30% per year. Second, it supported a common data format and access
protocol so that wherever you were in that network, no matter what type
of machine you were sitting at, you could access any piece of data that
was of interest to you independent of what database engine or server it
lived on. Finally, it supported an application programming environment that
allowed you to write applications once in a simple object-oriented language,
and run them anywhere in that network environment; again, independent of
the operating system with a microprocessor. Would that sort of networked
application environment be of value to you?" Because that's exactly
what we've built up to this point.
The Internet provides that pervasive connectivity, and now corporate intranets
are moving that technology into the enterprise. HTML and HTTP are becoming
that common data format and access protocol. And Java is becoming the language
that allows you to write applications once, and run them anywhere on any
device, and more importantly to be able to safely download those applications
from across the network.
That's a little bit of stage setting with respect to where we are today.
There's an enormous amount of momentum behind Java. I think there are probably
four reasons why there's so much momentum. First of all, Java truly represents
an alternative open platform for the computing industry; an architecturally
neutral platform in which you can write applications without worrying about
which microprocessor, or which operating system you want to run them on.
Second, safe network delivery allows you to write those applications specifically
for a networked environment. Perhaps the most exciting use is being able
to embed executable content or applets within Web pages, so that Web pages
come to life, not just with animation, but with sophisticated new user interfaces,
and user environments for manipulating data embedded within the Web pages.
Third, and perhaps even more important to you all, is that Java lowers the
entry barriers for new application developers. It lowers your investment
dollars-you write the applications once and get access to a very broad base
of end users. You no longer have to worry about shelf-space problems or
cost of goods. Your applications can be delivered across the network and
ultimately sold across the network. Perhaps even most important, you don't
need 20 or 30 megabytes of code to be in the application business. An applet,
or a collection of applets, makes a nice entry product in this new space.
Fourth, We have an environment that is making it far easier for a new generation
of application developers to burst on the scene and create value for you,
for the industry, and for end users. Java makes it much simpler to manage
software in an enterprise environment. In an enterprise that has thousands
or perhaps tens of thousands of desktop devices, and you want to upgrade
your software, you don't have to go re- install across all those devices.
When you put the upgrade on a server, it will be automatically downloaded
as needed.
How did we get to the point where we've generated all this momentum? Let's
talk about the typical product-entry cycle. You spend a couple of years
in the research lab, trying to come up with a new product concept. Then
you spend a couple of years pushing that through a development process,
trying to shape it into something that you believe has market value and
will be robust in the marketplace. Next, you deliver your product into the
marketplace and then spend years building interest in development and innovation
around it, build a user base, and if you're lucky, at some point, maybe
three, five, or seven years down the road, you have a product that's of
value.
But suppose for a moment you had a very different type of environment for
delivering a product into the marketplace. Suppose that product could be
delivered to the marketplace at zero cost. Zero cost of goods sold. Suppose
that product could be delivered instantaneously to all developers and all
users; creating immediate innovation and collaboration around that product;
generating interest and demand for that product and the products built upon
it; and providing instantaneous feedback with respect to how you could improve
that product.
In fact, that's what the Internet has done for us. That's what we at Sun
have leveraged to help Java achieve the momentum that it has in the marketplace
today. We began by making it available on the Web to anybody who was interested
in experimenting with it, building upon it, and using it. That generated
an enormous groundswell of application development, creating interest in
a very short time among the user community, and bringing value for all of
us.
Earlier this year at Sun, we created a new operating company called
JavaSoft(tm).
JavaSoft was put in place specifically to help Java achieve its full potential
in the marketplace. We've defined for ourselves four goals that we try to
keep in our minds everyday as we come to work.
It is our goal to evolve and maintain Java as a complete programming environment,
not just another language, but an environment with complete system functionality,
and an environment in which you can build rich, sophisticated, creative,
innovative applications.
It is our goal to drive that environment to be pervasively available across
all computing devices, not just traditional PC desktops, workstations and
servers, but to Internet terminals, consumer devices, telephones, pagers,
and embedded controllers-anything that feels, smells, walks, or talks like
it has a processor-we'd like the Java Platform to live on it.
We want to encourage a rich and effective base of applications through communicating
with you all, working with you, learning from you, and evolving the technology
and platform in ways that you think make sense, and are important to do.
We would like to build for JavaSoft and Sun, in the same way that you would
like to build for your businesses, a profitable product family, consisting
of platform products, application enablers, and services.
What I'd like to do now is spend a few minutes talking a little more about
each of these goals, and in particular our initiatives in each of these
areas.
Relative to evolving Java into a complete programming environment, today
we have the Java Language; the Java Compiler that compiles applications
written in that language into a machine-independent intermediate form; and
then the Java Virtual Machines, one for each operating system or microprocessor
in which you'd like Java applications to be executable. What's missing are
those programming interfaces and libraries that provide access to a rich
base of underlying system functionality. For example, support for use of
rich media types: 3-D, video, audio, image, animation, and support for enterprise
connectivity, database access, remote objects, cryptography, and so on.
It's those APIs and libraries that we are focused on developing and integrating
within the Java environment.
As far as driving to deliver this platform across all computing devices,
our approach is slightly different for the higher end desktops and servers
than it is for the lower end, Internet terminals, consumer devices, and
embedded controllers. Relative to desktops and servers, our approach is
to work with the existing operating system providers to ensure that there
is an efficient and complete implementation of the Java Platform within
their operating systems.
To that end, we've announced that we've licensed almost all of the major
operating system providers. They will take the Java reference implementation,
tune it for their particular environment, and deliver that with each copy
of the operating systems that they ship. This means that there will be an
efficient implementation of the Java Virtual Machine on every copy of the
MacOS and every copy of Windows 95 and Windows NT, AIX, OS/2, MVS, HP-UX,
Solaris, NetWare, and so on.
Even more importantly, as the implementations are refined and tuned for
each of these operating environments, the licencees are committed to remaining
compatible with the reference implementation we provide. As we encourage
innovation across all of these operating platforms, we are also insisting
that applications written in Java will run well across all these implementations.
Every implementation that's shipped is required to pass the test suites
that we deliver. As we upgrade the capabilities and functionality of the
Java Platform; and upgrades are added to the operating system, these upgrades
will also pass the new test suites. This way, we continue to remain uplevel
across all operating environments. So that as you write to the Java reference
implementation, you can be assured that it will run efficiently across all
those operating systems.
Relative to Internet terminals, consumer devices, and embedded controllers,
we have a very new product that I'm going to announce in a minute called
the JavaOS(tm). The Java operating system is written specifically for those
devices, and a large set of companies are prepared to endorse that operating
system.
Finally, applications, applications, applications. When people say to me,
"What's important for Java to be successful," the answer is always
"Applications, applications, applications," the work that you
are doing. There's an enormous amount of work already going on around the
development of applications for Java, from large ISVs, (and you'll be hearing
from some of them through the course of the next two and a half days) to
systems integrators; Andersen Consulting, for example, has developed a set
of custom applications written entirely in Java for specific customers;
to corporate IS organizations that are using Java to build a new generation
of internal administrative applications, to the new generation of Web and
Java developers-EarthWeb's Gamelan Web site, for example, now classifies
over 2,000 applets in a broad range of categories.
There's already an enormous amount of application development underway within
the Java Language and the Java programming environment. It is our goal to
put more and more effective developer support programs in place to help
you do the things that you know how to do so well.
I would like to make a set of announcements this morning. These include:
the JavaOS, the new HotJava product, enhancements to the base Java developer
kit, a project we call "Java Beans" (I didn't come up with the
name), and then our new on-line Developer Support Program.
The JavaOS is an implementation of the Java Virtual Machine written directly
to the microprocessor. It is a native Java operating system designed to
be the smallest, fastest implementation of Java. In its minimal form it
only requires about 512-K bytes of ROM, and about 128-K bytes of RAM. It
is truly an operating environment that can fit in embedded controllers.
But because it's Java-based, because it's written in Java, it can easily
scale up. In fact, it can automatically download additional system functionality
from across a network on an as-needed basis. This is our target for Java
as the operating environment on everything from Internet terminals down
to consumer devices like telephones and pagers, and on down to embedded
controllers.
I'm delighted and proud to announce that over 40 companies are now endorsing
the JavaOS. This includes 30 systems companies who will be using the JavaOS
as the operating environment within their Internet terminals, or net computers,
PDAs, set-top boxes, telephones, pagers, and a variety of embedded devices.
As an example, I'm holding a new PDA from Mitsubishi. It has an x86 microprocessor
inside and is running the Java operating system. In fact, if you go down
to the display booths, you'll be able to take a look at this in operation
today. It has a nice little screen, a pen-based system, and everything else
that you'd expect. However, it's running Java as the native operating system.
Nokia will be using the JavaOS to build intelligent telephones. Oracle has
selected the JavaOS as the base operating environment for their next generation
of net computers. Acer will be using JavaOS to build consumer devices. Toshiba
will be using the JavaOS to build their next generation of Internet terminals,
and the Taiwanese government has endorsed the JavaOS for its new network
appliances industry.
In addition, over ten microprocessor architectures will be running the JavaOS:
Intel x86, PowerPC, SPARC(tm), Arm, the new Java chips, and the list goes on.
We have many applications and tools vendors that are adopting the JavaOS;
including, Corel, Justsystems, Symantec, and SunSoft.
When we talk about the fact that the JavaOS, and Java more broadly, is going
to be available across all computing devices, we mean it. It will be available
through the traditional operating systems for desktops and servers, through
JavaOS as well as through the use of Java in a variety of other existing
real-time operating systems, for lower end, Internet terminals, consumer
devices, and embedded controllers. So if you write to Java, you will have
the broadest base of devices and end users anywhere as your target customer
set.
The second thing that I'd like to announce is the HotJava user interface.
Many of you have heard about HotJava. In fact, I'd be surprised if many
or most of you haven't already used HotJava, although I suspect that probably
all of you think of HotJava as a browser. In fact, HotJava is not a browser.
HotJava, in our view, is a dynamically extensible network desktop environment.
One simple way to think of HotJava is as the user- interface subsystem for
the JavaOS.
But, it's even more than that. HotJava is an environment and a set of libraries
that make it easier for you to build client-side, network-oriented applications.
Think of it in this way; HotJava is a piece of software written in Java
that manages end-user input and output, keystrokes, and mouse clicks, but
you can also plug into HotJava new content handlers or protocol handlers.
In addition, because it's written in Java, you can easily add new classes
and methods, and new graphical elements, including graphical control elements.
If I write an HTML content handler and plug it into HotJava; an HTTP protocol
handler and plug it into HotJava; build a forward button, a backward button,
a load button and a stop button, boom-I have a browser. That's what many
of you see today when you download the prebeta of HotJava. I can just as
easily plug in an SMTP, mail transport protocol handler, a set of my mail
content handlers, a read button, a compose button, a send button, and I
have a mail client.
Perhaps even more exciting, HotJava can take those content handlers and
control elements, download them from the network, and install them on the
fly. HotJava can actually morph itself while you're using it. Imagine for
a moment that you're using HotJava configured as a browser. You're in Yahoo,
and you click on a link to the Disney Web site. But instead of getting just
the Disney page, Disney sends you a new set of control elements. They take
complete control of the screen, of the application environment, building
a branded, complete user environment for the Disney experience. Now you
go to Fox-a new set of control elements; a new branded, complete user experience.
Maybe you go to AT&T and HotJava morphs itself into an integrated mail browser
package. This is what we mean by HotJava.
What I'd like to do now is ask Stuart Richie to come up and give you a quick
demo of the JavaOS, running HotJava configured as a browser.
Richie:
Only three feet off the ground here, but I can still feel, I think, what
you're feeling up there, so...
Baratz:
Want to trade places?
Richie:
No, you're doing a great job, thanks a lot. On the screen to the right,
you can see JavaOS running HotJava on top. What I thought I'd do before
I run through the demos, is tell you a little about what the software is,
and what the hardware is like. I'm showing you HotJava as the main application
on JavaOS today, because I think it's a great demonstration of the graphical
and networking capabilities that JavaOS can give you.
I'll start off by looking at our old Home Page. I like our old Home Page
because it shows a fair amount of graphics, and we have an applet in there
to show some movement. But, before I go deeper, I want to drive one point
home: both HotJava and JavaOS are written in Java. Our networking code from
the device drivers all the way through TCP is in Java. The windowing code
is in Java, as well as all the buttons, all the scroll bars, and so on.
We're handling interrupts in Java, so this gives us a number of advantages.
One of them is portability. Portability is a big concern when you're going
across multiple CPUs. The other advantage, as a developer on the JavaOS
team, is productivity. How would you like to debug your device driver as
applets? Hands up? I think that's a great way to go.
As for applets, I'm just going to navigate through a few of these pages
and find something interesting to run. Initially what I'm going to show
you are the toy applets that we have on the Java Home Page. I think these
do a good job in displaying the graphics and 2-D imaging performance that
we have.
Remember, all of this is being pre-interpreted as byte codes. We're not
using any special hand-tuned, "ten-man-year" interpreter. This
is the standard interpreter that you have. I think we're doing a good job
at rendering and downloading code using the network. So these are a few
little applets.
I'm now going to show you a more serious conceptual type of applet. This
is a Kodak photo CD catalog where we have a number of high quality images
stored on a standard HTTP server. These images are roughly 5-megabytes each,
certainly more than this little Java terminal prototype can handle. This
is an example of where we have server support doing some "bit-crunching"
to generate images. I can select the tiger here, do some enlargements and
bring the new images over. There we go. I'm making a nice big tiger. Everybody
can see him. Much of the computing that's going on here is on the server
side. This allows this little Java terminal to act as a user interface.
You might see things like low-cost Java terminal-type devices being shared
by a high-end server. This is a very good, cost effective way of dividing
cycles across many stations.
Now, for my last demo: I love poking fun at people, and I know you're all
going to recognize this gentleman here.... I think James has good reason
to be happy, and he's happy in this picture. But James, I'd like to give
you a better smile [expands the smile on the screen] because I think this
is a really great day. Now James, won't you wink for us, please? Thank you
very much. Alan...
Baratz:
I don't know whether you all caught that or not, but one of the things Stuart
said was that TCP/IP is running on this machine written entirely in Java.
Here we're talking about; what some would consider a soft real- time piece
of application code, or system code, written entirely in Java. Thanks, Stuart.
We've talked a little bit about the JavaOS, the new product that we're announcing
today, and HotJava, the dynamic network desktop environment product that
we're also announcing today.
What I'd like to do now is talk about some enhancements and extensions to
the base Java Developer Kit, the Java reference implementation that we'd
like to announce today as well. There are a series of things that we are
doing and will be delivering very soon to enhance the Java Developer Kit.
First, to substantially improve performance by tuning the virtual machine,
and tuning the class libraries. Second, we are enhancing the functionality
and performance of the AWT because for many months you have been telling
us that this is important to do. We are working on it, as it is critically
important for us as well. We will be delivering that very soon.
Finally, there's internationalization. I had the opportunity to visit Japan
about two weeks ago, and the single most important message that came from
every one of those meetings was internationalization and localization. This
work is also well underway. In addition, as a part of the next iteration
of the Java Developer Kit we will be integrating some of the API and library
work that I talked about earlier.
However, before getting into more detail about that, let me talk about how
we're doing that work. We are not evolving the Java Platform purely as an
internally, Sun-focused initiative. Absolutely not. Java is being evolved
as an industry initiative. We are identifying leading industry players with
expertise in key areas of enhancement required by the Java Platform, we
are working with them to develop the APIs and libraries. As an example,
for the 2-D APIs and libraries, basic font technology and imaging model,
we've announced that we're going to be working with Adobe, and incorporating
the Adobe imaging model within the Java Platform.
We're evolving the platform in collaboration with key industry players.
As we evolve the platform, as we add new APIs and libraries, we are insisting
that these editions remain open in the same way that the base Java Platform
is open: completely specified interfaces, detailed enough to be able to
develop clone implementations. We are insisting that all the library work
be done in a platform-independent fashion, written in Java as much as possible,
but when not possible, implemented across all platforms.
More specifically, there are six areas in which we are evolving the Java
Platform, relative to Java Media API, the APIs and libraries that allow
application developers (all of you in this room) to utilize a rich base
of media types in building your applications: Everything from 2-D, to image,
to animation, to audio, to video, and to telephony support; there is the
Java Enterprise API for accessing database systems and managing access to
remote objects written in Java, or any other language for that matter, including
full CORBA compliance. There's Java Security: the APIs and libraries for
key management, block cipher, streaming cipher, and, of course, digital
signature of both data and software. There are the Java Management APIs
that allow you to provide rich and sophisticated system management across
all devices that support Java. These are the Java Commerce APIs; in particular
the Java Wallet and the ability to plug into the Java Wallet a variety of
different payment protocols and payment systems. Finally, there's the Java
Servlet API that allows you to build Java applets, upload, and install them
onto servers, in addition to the state of affairs today, where you can download
applets and install them onto clients. There's one other critically important
element to enhancing and evolving the Java Platform, a project we call Java
Beans or the Java Beans initiative. Java Beans is all about allowing the
use of components within applications, or applets, to be shared across applications
or applets. That a component, or a bean-now you know where the name came
from- that a piece of a Java applet can be reused by a variety of other
applications or applets. This is not only for a Java environment, but also
to allow, for example, an Excel spreadsheet, or a Word document to access
a Java Bean or a Java component. In fact, we are supporting bridging for
OpenDoc, ActiveX, and LiveConnect, so that Java Beans or Java components
can exist as objects within all of those architectures. If you want to extend
Excel, you can write that extension in Java and it can be linked in through
ActiveX.
We have already been able to establish broad industry support for the Java
Beans initiative, including Borland, IBM, Symantec, Netscape, Oracle, and
Lotus. They have all said that they are supporting the Java Beans initiative,
the Java Bean set of APIs.
The last announcement I'd like to make today is that, effective midsummer,
we will be providing a new on-line Developer Support Program. One of the
things that I have been most concerned about over the course of the last
several months, and I suspect that all of you have been concerned about
too, is that it's been very difficult to get access to the people within
Java who have been developing this technology. You have a lot of important
questions that need to be answered, and you have a lot of good suggestions
and comments about directions that we should be taking. Beginning midsummer,
July 31st, we'll be establishing a new Web site that will be an on-line
developer community, a place where you can get up-to-the-minute access to
information about Java; participate in Java courses on line; ask questions
of the experts, and participate in forums or chat sessions. Over time, we
will evolve this into an environment in which you can trade classes or applets,
an environment that ultimately provides a retail distribution channel for
you to deliver your products to end users or consumers for a fee.
Today, we've announced five new products and initiatives for JavaSoft, Sun
Microsystems, relative to the Java technology. We've announced the JavaOS;
the HotJava user-interface environment; enhancements to the Java Developer
Kit; the base reference implementation; the Java Beans initiative, the component
APIs for Java; and finally, the new on-line Developer Support Program.
Our goal is to develop an environment, an industry, in which Java is broadly
available across all devices from chips to high-end servers with development
tools and a rich, broad base of applications. I'd like to thank you for
your time and I look forward to seeing you as the two days progress. Thank
you.
Gage (Host):
Well, all of you now know you can reach Alan Baratz at alan.baratz@sun.com.
Mail him if you have anything you want him to do. You heard his promise.
We'll give you a choice of email: you can have either the Disney front end,
or the Fox front end. We're going to have "Little Bo Peep email,"
or "Bay Watch email" or "X-Files email." That's what's
coming. If any of you can build that, I'll buy it instantly.
The other names I want to give you for JavaOS are: Jim Mitchell, for those
of you that know Xerox PARC, he worked on the Mesa Project, another byte-code
oriented way of doing things. He can be reached at jim.mitchell@sun.com.
And John Kannegaard and Mike Clary. These are the central people of JavaSoft
who reach out to the world, drive the technical development, and then sign
you up and give you the technical and commercial support you need.
Now, you all have this program for JavaOne. This is very much like most
software today. It's pretty and it's wrong. This is statically allocated-
someone thought about where we would all fit for the next two days and everything
has changed. [continues with details of day's program] Thank you
very much.
James Gosling/JavaOne Page
