MR. GATES

It's great to be here at Tech Ed. This event has grown and grown over the years, and it's just fantastic to see the level of interest that's out there. Today, between the group here in Orlando and the groups out around the United States and Canada at movie theaters, we have over 15,000 developers. And this includes all the most influential developers who are building the great applications that are driving computing forward.

We're going to talk this week about Windows -- where the platform is going. It's been fantastic to see the growth in the Windows platform. It was in 1990 when we reached the turning point and could see that that the bet we'd made where we've got the entire company on graphics interface and Windows was going to pay off. And every year since then the number of applications, the number of users, and the richness of the platform has continued to grow. In fact, the vast majority of all computers now are running 32-bit Windows.

You can see in this diagram how in the last four years the portion of systems running Windows has increased rather dramatically. Whether that's replacing DOS-based character mode systems, which are a lot of what you see in the decline here, or even competitive graphical systems.

Now, a major initiative we have is to get Windows users up to the 32-bit levels. We kicked that off in a very big way with Windows 95 in August of 1995. And the progress in moving the base over to the 32-bit has been really quite fantastic. Month by month, the Windows 95 upgrade continues to set new sales records, and the adoption of Windows NT Workstation has been well beyond what we would have expected. Today, the 32-bit base is over 65 million machines, and well over 90 percent of the new machines that are purchased, whether they're for a new user or a replacement machine.. So this is the target platform for all new applications.

Another wonderful thing is how the incredible increase in PC performance has moved the PC architecture to be the server of choice. Now, when people think about servers today, they think about a lot more than just high-speed file sharing. They think about messaging and communications. They think about running script and running applications that are up on the server. And so the market has shifted from specialized servers to needing a general purpose server with a fully capable, secure, operating system. Windows NT was timed perfectly to take advantage of this shift. In 1996, we had over 700,000 new NT servers. In the last 12 months, we've now exceeded a million new NT 4.0 servers. That's quite a milestone, taking us well beyond the number of Unix servers that are out there, the entire installed base, and taking us beyond the latest version of Netware.

The improvements in performance that are allowing Windows to be dominant on the server are going to continue at quite an incredible pace. We have Intel coming out with a Pentium II, which is a fantastic step, moving the clock speeds all the way up to 300 megahertz, and they'll continue to move those up in the next several years. Eventually we'll have clock speeds that are thousands of megahertz and the performance increase that goes with that. We're also hard at work with Intel on their IA-64 platform, the so-called Merced chip, and there's some pretty amazing performance that will come out of that. This is all focused around Windows NT and the momentum that it's built up.

We not only get improvements in the individual microprocessors, we get the ability to use more processors in symmetric multiprocessing configurations, moving from two to four, now to eight and 16-processor configurations. Even more exciting is how you take those symmetric multiprocessor machines and cluster those together. And so, on the performance front, the progress will be really quite stunning.

In late 1995, the big agenda for Windows became the Internet. We announced in December '95 that we were going to go into every product and build Internet standards into the core of those products. It was a real challenge to us because we needed to get that done and get Microsoft in front of the incredible phenomenon around the Internet. So we committed to getting a state-of-the-art browser out and a state-of-the-art Web server out. In 1996 we were able to more than fulfill all of those promises. Today our progress is very solid. Our browser share is 25 to 30 percent, and growing on a very rapid basis. And our Internet Information Server, which, of course, is included with NTS, is now the most widely used Web server.

So we've come a long way, and now Microsoft is putting more into these Internet standards groups than any other company. The growth of the Internet is key to our future, and you'll see all the things we're doing, whether it's with the Windows client, the Windows server, or with our tools, to make it very easy to take advantage of the Internet. The theme of building distributed applications really comes because we're going to have this Internet connectivity. And so all this talk about how distributed applications would be important, now it's absolutely the case. Now we need to make it easy for people to really get that done.

The Windows family has quite a range from a small little hand-held device running Windows CE or a WebTV box connected up in the living room to your TV set, all the way up to these clustered multiprocessor servers that I talk about. Each of the tiers in this family have an important role: the desk-top PC, the portable PC, the Net PC that guarantees that you can remote boot, auto-configure at all times, even set things up so there is no client-side state. We simply use the disk as a task, and you can administer things simply from the center. That's a major breakthrough in PC state management that will come with NT 5.0.

We also are adding into the family what we call the Windows Terminal. This is for light users. If somebody wants a client that is quite simple, you don't want to have to build a browser and a growing operating system into that client. You want to offload that work remotely and have a very few devices doing essentially video protocol. That can work very well. And so it's the only truly thin client that will be available that will allow people to run Windows applications get the benefits without redeveloping their applications.

This family is spanning a range of hardware where the different in price is over a factor of a thousand, the difference in performance is over a factor of a thousand. But you get to share the same user interface and the same development construct, so the applications go from top to bottom.

The key to the success of Windows is the work that all of you do. The work of professional developers. So we track very carefully the feedback we're getting from developers, and what we need to prioritize in Windows. Here we're showing primary development language usage. Actually, the Windows line is a little different. That shows us, when we asked developers what operating systems they target, what percentage indicate Windows. And that's now up at over 90 percent.

With the languages the question was about their primary language. Many, many developers use a number of languages. In fact that's a big theme of the Visual Studio product we came out with a few weeks ago. It makes it easy to mix and match code from different languages. For primary language it's Visual Basic very, very strong, about half the developers were using that as their primary language; C was very strong at over 20 percent; and now Javais coming on very strong, almost 10 percent of developers saying that it will become a primary language for them.

Now, these numbers were taken in the United States, where the Java phenomenon is stronger. We haven't seen that yet outside the United States, but we do think Java is quite important, and we're doing the leading work to make it debuggable, to make native code compilable, and to allow you to continue to work with your existing code, and to fit into the Windows environment, while getting the benefits that Java provides.

If we look historically, there have been a lot of initiatives that Microsoft has undertaken to drive the leading platform. Back in the early '80s, I mentioned we bet the company on graphics interface, on Microsoft Windows. There were other systems that were viewed as competitors there -- GEM and ViSion. Probably the two most notable were the Macintosh and OS/2 over a period of years in terms of volume and leadership, Windows greatly outdistanced those systems and got the benefit of the positive feedback. That is, the more applications there were, the more volume we got; the more volume we got, the more applications there were.

The next big platform challenge was much more in terms of networking. Who would build the most popular server operating system? Who would make it so that you could manage a large network of computers? And here's where Netware came in. Netware had dramatically more volume than all the flavors of Unix put together, and it ran on the PC hardware base and fulfilled something that was very important to people -- simple, file based information sharing. Likewise, for the client for robustness and richness, we had Unix. And a number of areas where people needed the very high performance and were willing to pay a lot to get it, Unix was very dominant. Areas like real-time financial applications, engineering applications. So there were quite a variety of people going after this client/server opportunity.

We came in to it saying, "well, let's have the same operating system architecture on the clients as on the server. Let's let code easily move between client and server. So that, when I go off with my portable machine, I can take my business rules with me and sit in front of a customer and work things out. But also I can have those same application codes run on the server at night, process data, find interesting results and even trigger electronic mail notification out to users, so when they come in, in the morning, they have access to the information that they care about."

So our approach was building Windows NT, and getting the momentum there by taking the best of Windows, the best of NetWare, and the best of Unix, and putting those into one system. It's a very ambitious project and I think this is the first Tech Ed that I can safely say without any danger of anyone contradicting it that Windows NT is the mainstream, and there's no doubt at the server level that it will be the same standard that Windows is on the desktop.

Now there's a new platform competition going on, and this is over distributed applications. Here we've got Oracle with an approach building out of their database. We've got IBM with a number of initiatives still based around DB2 and the middleware that they provide. And then we have also Sun and Netscape with their own initiative about how people should build these new applications. Everyone is taking the Internet as the starting point and saying, "Okay, the world is going to be connected together." The speeds will get higher and higher, and this will transform all businesses. The way you'll think of working with partners and customers will be quite different. And even in the near-term, the ability to move information around your company in a far better way than paper-based systems or simple file sharing is quite exciting. The paybacks are pretty incredible.

Here Microsoft is taking the Windows architecture and enhancing it for these applications. And that's really what I want to elaborate on today. How what we're doing with our very large R&D budget is to build Windows as the most powerful distributed platform.

The previous big battle in computing paradigms was between centralized computing and personal computing. Personal computing gave people more flexibility, and it really let people throughout an organization deal with information. And so it really overwhelmed mainframe computing.

The mainframe advantage was the simple administration. And, in fact, the machines were very compatible because the plug-compatible manufacturers came in with the same operating system structure. As people moved to Unix, the idea of a common operating system never caught on. There were committees coming up with things that were common between the various systems, but each manufacturer continued to have its own developers and its own engineers, leading to fragmentation. And so, although there are a lot of great ideas that came out of that, and a lot of systems out there that are very important to interoperate with, it never achieved the critical mass to be the leading paradigm.

Now, we've got a proposal for a new paradigm --people who want to push what they call the network computer. And, of course, it's not a continuity step from any existing paradigm. It's an attempt to build a new interface, and ask people to rewrite all of their applications. Now, that's very unusual. There's never been a continuing paradigm that didn't draw on the investments people had previously. For example, personal computers ran Cobol applications and had 3270 terminal emulation. So they made an effort to fit in and not force a total rewrite because that's just too difficult.

For the personal computer, we do have a lot of work to get to distributed computing, but we can deliver that in an evolutionary fashion. When people see this slide, there are really only two things they raise to be skeptical about. Can we, on the PC architecture, build a distributed computing environment that delivers on all the promises that the other environments have had?

The first question is manageability. Can we make it low cost to deal with all these machines? There's been a lot of focus on that now, looking at desk-top cost of ownership, looking at network cost, application development cost, data center cost. When you put those all together, the investment around the world is quite amazing. And there's a lot that can be done to make that simpler.In the same way that in 1996 Microsoft's theme was the Internet, for this year, 1997, the theme is manageability. And there are some real breakthrough things we're doing that will bring the cost of this down quite substantially. So manageability is our first challenge.

The second challenge is scalability. Can we make it easy with these machines to run the most demanding applications. Applications that would overtax even the most expensive mainframe or Unix-based system? We've set those priorities, and you're going to see a lot of releases, a lot of things around those themes. This month, May 20th, we'll have an event in New York particularly focused on scalability, moving performance up to a whole new level. Primarily, you've seen the clustering software as a big breakthrough there.

So what do these applications have to look like? Well, they've got to be easy to develop. They've got to avoid duplicating the same things that other people are building. Anything that's common between the applications, you'll want to put it in the infrastructure, which means in the operating system. You want applications that can be modified very easily and maintained using a component-type approach.

For users, they don't just want screens, they want to be able to take the information of these applications and view it in different ways. They want to bring it down into a spreadsheet. They want to set rules to tell them when exceptional conditions exist. So it's more than just printouts or screen displays. They want to mix this in with their productivity tools, and their work group capabilities. They want to customize things so they see the information they care about. And they want the applications to roll out to their desktop without any complexities, without overloading the storage or having file conflicts. They just want to click on an application, and boom, it's immediately available to them.

But they don't want to give up the performance that they've had, and so the code has to come down and run on their machine. And they don't want to give up portability. They want to be able to disconnect that machine and go out and use it wherever they go. And so the operating system is going to have to do a lot to make it easy to build these applications.

We need to get from where we are today to these future applications -- meeting the customer requirements, distributed, interoperable, multi-tiered, Web-enabled so in some cases a browser user can get in and see the information, work group-enabled so somebody with more than just a browser can do a lot with the information -- make sure that you don't run out of gas as you move forward, and make it all simple to administer. Those are pretty demanding requirements. To meet those requirements so far, application developers have had to do an immense amount of work, particularly given the rate of change we have right now that comes with Internet-based technologies. It's been very hard to deliver on these things and keep up with all the latest.

The answer is for a lot of this complexity to be in the operating system and so the component model provides it without the developer having to do that work. That means leveraging the services that are there. Now, we're not going to do this by requiring people to use a particular language, or even a particular tool. We are going to sort out all the tools that are out there, all the languages that people are used to -- Visual Basic, C, Java, Cobol -- you name it, we'll support it with this rich infrastructure.

Part of the beauty of that is not only the choice of language, but being able to use existing codes. We're going to make it simple to go back into existing code that has not been browser-enabled or has not been multi-tiered and put in some transaction support, put in the ability to use forms that are delivered through the browser. So the investments of the past will be able to carry forward.

Deployment of applications is an area where we need a major breakthrough, and we'll be talking about what we're doing there, where you just click on a link, whether it's in a mail message or a piece of OLE documents, and you click on that link. We'll do the install for you, as well as get rid of the application when you're done using it in a very automatic fashion.

Here's the architecture diagram that has got all the pieces coming together. You can see that in our distributed computing architecture our component object model, COM, plays a very fundamental role. It is the thing that connects all the devices -- the Windows device, the PC, the browser, all of these -- up to the business applications. And the business applications, which are broken down to components, can rely on rich services that come from the system, again using COM as a way of connecting up.

Those services will not just come from one machine. It will come from multiple servers. When you want to build the applications that are totally reliable, you need the idea of being able to run against any server. If you want to be scalable, you need the idea of being able to run against multiple servers. This is very complicated, because the server can fail in the middle of an operation, and you have to have a lot of logic about spreading out the work that you've done. You have to know when you want to run a multiple server -- which one is available, which one is the right one to pick to do something. That's why very, very few people have been able to do great client-server applications. It's just too complicated building up from what people thought of as the operating system in the past -- security, message queuing, transactions weren’t there. All you had was SQL running on a single machine, and the file system type storage. So we are going to raise that infrastructure of the operating system support up to a new level of richness.

COM is at the center of this. All the new things we're talking about here are services that you will call using this COM capability. We made some real breakthroughs for Visual Basic users to let them get at the full richness of COM. We've done a lot of things to make it easier for C developers to get at COM. Our initial design that goes back about four years ago had language and applications independent to the center, distributed capabilities, and the opportunity to run on all platforms. That's one thing about COM. It is much bigger than Windows. Code using COM can run on Unix, Macs, anything that's out there. And that was the theory from the very beginning. The richest COM services we believe we’ll be able to deliver in Windows. But none of the code that's written this way is tied into that.

This year COM has achieved some exciting milestones. Distributed COM is part of NT 4, and so the growth of NT 4 is moving that along. There is over $200 million of revenue from people who sell components. This has been talked about for ages and ages -- you know, when would it be possible to just go up and get a data controller, or a graphing control and just drop that into my application, customize it up, and I'd be off and running? And when will it be economic for companies who build those things to have a business that's an ongoing business where they can make that library of components richer and richer?

Well, it's happened. Object technology, which has been discussed over the last decade, has finally arrived to create software component businesses. And we expect this to continue to grow and grow. The biggest part of it will be developers going out to get components. End users will benefit from components because they will be more flexible, but we don't expect the end user to be in the position of having to pick and match a bunch of components and test them together. They'll turn to a developer and say, you know, "Is this a package that you've built, tested as a whole, and I can count on you to support it?" The power of that package will come through the components.

This year we licensed COM to the Open Group. When we say, "licensed," we mean the source code is up there, there are no intellectual property restrictions. It's available to anyone who wants to put it on their platform. In fact, through a number of partnerships, the Datacomm is out now on Unix and MVS , and that will go final just in the months ahead. So we can say that COM will certainly be the first object model out on multiple platforms supporting multiple languages. It's real progress here, and something the industry has looked forward to for a long time.

Well, having gotten COM to critical mass, we're getting a lot of feedback about where we need to go with it. And there are some great ideas, including some breakthroughs in making it easier to develop in COM, all upwards compatible. We need to get the full deployment of the final versions on Mac and Unix. As I said, that's imminent. Today we'll be talking about an announcement where HP and DEC, Digital, will be including COM support in their operating systems. So it's not an add-on; it's something that comes with the shipments of HP-UX and Unix that these companies make.

We've got a richer set of security capabilities. It's a safety model that allows different levels of trust to be given to different pieces of code. We have advances in letting portable machines be a user of COM, and as soon as it gets plugged up it gets connected in and does deferred operations. And we have some rich ways that we are integrating COM down into Windows in a stronger and stronger fashion. And so we've really increased the importance of COM. in the next release of our languages, the big theme will be these advances in COM and how we make it even easier to build those components.

The run-time services will be far richer than they have been today. Debugging will get a lot simpler. We'll have persistence as a standard feature. We'll have garbage collection for all the objects that you have used from any language. And we'll have native code support. This draws on all the best ideas of the last few years about object models, and yet does it in a way that doesn't restrict you to a single language or even to recreating the code that you have.

Now, automatic component management is a part of this that most developers have never seen before -- being able to have the operating system figure out where the components should run, and if there is any type of problem -- a machine goes down, you get storage overflow -- being able to use the concept of transactions to back out the partial work that was done, make sure the system is in a consistent state, and then restart the transaction with the resources that are still up and running.That is a crucial advance, and we'll never have a great Internet where people feel, "Okay, I just go out there, I do transactions, it always works," until we have transactions at the center of the system, built into the operating system and easy to get to from the tools.

There are pieces of this -- the connection management, the binding of the calls between the components, figuring out how to use threads so that these things run efficiently, and being able to run things when necessary. Sometimes when you invoke something to happen you want to wait for it to happen; but other times you simply want to say, "Hey, do this later," and then set a deadline -- be notified if it hasn't been done by then. That kind of flexibility of procedure calls hasn't been available, and yet it is very, very important in this distributed environment.

So the richness here will come without giving up the interoperability -- interoperability across systems and with different codes. It's fascinating to look at all the projects at Microsoft and see what a high percentage of them relate to interoperability. I find it almost ironic that in the year where Windows is the most preeminent, the investments we're making in working with other systems are even greater than before. I've listed a number of the initiatives here -- all the Internet standards, which are fantastic things; cross-platform transaction standards, called XA, that we have in the Microsoft transaction server from the beginning; database connectivity; ODBC and the extensions taking place there that we've been the key company driving those. And just that one initiative alone has given people database independence. You write your code in a way that it doesn't matter what’s at the back end. As do all products, it's going to run again. SNA -- obviously an IBM-driven standard -- the one where we've done an implementation in the Windows environment that makes it easy for people to connect in. And we're continuing to do rich new things. Java -- we've gotten out in front of that with the most popular Java tool, and with messaging protocols. And many, many, many more things that we're doing for interoperability.

Our great successes come with an approach of embracing anything that's popular and then coming along with extensions. That's the approach that worked for us with NetWare, the approach that worked in spreadsheets and word processing, with the Internet -- to embrace everything that's out there and make it easy for systems to co-exist. That's why having COM in the non-Windows platform is so important to us, because developers still want to be able to target those multiple programs in the work they do.

I talked about transactions and those becoming automatically available to anybody who uses the COM-based approach. The Microsoft transaction server has been under development for many years, and a subset of it is shipped with SQL 6.5, which we called the distributive transaction coordinator. Now the transaction server is out in beta form. And people who think of transaction management probably think back to CICS, and may even wonder, "Well, why do we need this in the PC environment?" The fact is that CICS did some wonderful things, and we can take those and move those into the Internet world and make it even more available. If you wrote for Unix or Windows environment, you had to deal with a lot of complexities in getting these components to work together. Synchronization is very difficult. You end up with semaphores and a lot of codes, and the bugs there that you come up with are very, very difficult to deal with and find. So all of that complexity was up in the application.

A theory here -- once you put the transaction server in, use COM to call it, we take on all of that complexity, and so it's down in the operating system that this gets done.

Well, we've not only got our transaction server, but we've got it interoperating with other transaction systems. And so I thought it would be great to give you a chance to see that in action, and to ask Jim Drennan, who is the project manager for this transaction work we're doing, to come out and give us a little look.

MR. DRENNAN: Thanks, Bill. You know, the important thing to the enterprise customer, as you said earlier, is they don't want to rip and replace the old system, and there are a few billion lines of Cobol code out there. So what we are providing with this technology is it sets a new standard for ease of use for that integration.

And I've already gotten the feeder component builder open. This is a tool that will allow us to import the Cobol definition and actually create components for the transaction server -- -- cut and paste this from one of the emulator products, and I'll simply open this up -- it 's not a real complex program -- we're just going to move $700.12 to the balance. And right here is the CICS COM area. Now, that's sort of a CICS version of a parameter list that we're used to in our environment. And I simply click on "add," and we're now going to have a component with a method called Cedar Bank that will execute the Cedar Bank program. So if we go ahead and look at the Cedar Bank component I've created, I can actually take a look at the method call here. On the account balance field we can see the standard Cobol definition. The particular decimal format is pretty important out there in the banking world. And I can simply adjust this if I need to change precision and scale. But since I know this is a currency field, I want to go ahead and change it from a double to a currency data type for VB.

And here's the difficult part. The Cedar technology is actually building that component.

MR. GATES: It's going to actually take the Cobol data and convert it into the VB currency format automatically as part of that?

MR. DRENNAN: And we actually will generate -- if we look here in the Windows Explorer, we'll see down here a type library, and it does say 6:50 a.m. -- my machine is still on Seattle time. And I can go ahead and install this in the transaction server simply by dragging it and dropping it. And you see the little green bowling ball.

And what I'll do now is we'll bring up a Web page and -- a pretty simple page -- it gives me a choice of checking my account balance or showing all my accounts.Now, just to show that we are not cheating about this, I'll go ahead and bring up the visual green screen. No, I'm not announcing a new product. And I'll go ahead and turn on the CICS debugger so that we can actually see down here when I click that I want to check my checking account balance, we'll see the transaction server actually executing here. We'll see the little ball start to turn in a second. And then over here on the 3270 emulation, we actually see the program has been invoked. And it hasn't returned to the browser yet. You know, you talk about transactions we want to wait for -- so if I go ahead and just cancel the debugger, it will come back here in the browser and tell me that I have $177.12.

Now, in addition to that, we imported the other piece that we use -- we're using the Sheridan grid control in this case, a piece of shareware -- and it will actually go out and bring in that data from that Cobol program on the mainframe. Now, the important investment isn't just in the code, though; it's in the training. So it's important that the mainframe programmer do what they understand, which is CICS COM area. And if we take a look in Visual InterDev, this is the actual script that we use for the ASP file. And you can see right down here that it's the standard method. So for your programmers developing VB, they don't have to understand anything about the mainframe. It's a standard method.

MR. GATES: They didn't have to know CICS or Cobol. They just did this indication?

MR. DRENNAN: Exactly. And for folks who want to learn more about this, Session DAT-310 tomorrow at 9:30, Janice will tell them all about it.

MR. GATES: Great. Thanks, Jim. [Applause.]

Well, we've also talked about Windows simplification. And the big theme there is what we call it Zero Admin Windows, making it so that you never have to go out to a desktop, redo the registry and follow an application or worry about what's going on. Zero Admin Windows has a number of elements in it. I alluded to the idea of making proper installation automatic, and it's far from that today. I alluded to the idea of software being able to find fixes and updates automatically, which we don't have built into the system today.

Another element is letting administrators easily control what it is that can be done with the different systems. And so while you can go out and get any Windows application and install that, the administrator can decide what does that user interface look like and where are they allowed to store their files in an easy fashion.

Now, as we were making a breakthrough in NT 5, being able to do all this, using the rich directory and being able to replicate all the client site data for the server and do that with all of the existing 32-bit clients, we realized there was a portion of this -- simplifying user interface -- that we could deliver on NT 4. So we pulled together what we called the Zero Admin kit that is now out in beta form and will go final in the next few months.

We also sat down with all the hardware manufacturers and talked about the Net PC, which was just a refinement of the PC. It's not a competitor to the PC. It's just saying, "Let's take that ISA box, where we couldn't do automatic device configuration, where we didn't have the boot protocol, and let's relegate that as a legacy thing." The Net PC does not have ISA. It's got the PCI box, and we can always boot the operating system on auto configure very rapidly. It's got the "on now" capability, so you can walk up to the device and it's always there and running.

The Net PC features will be in every PC over time, although you'll first see them in special products that we'll ship later this year. We're bringing the Web paradigm into the user interface for simplification, and we've added this idea of the Windows terminal for the very light user -- so a lot of initiatives related to simplification.

One that's very concrete now and that I'm very pleased with is this Zero Admin kit. So I'd like to have Chris Capossella, one of our product managers, come out and just give us a quick little tour of what it means to use the zero-admin kit.

MR. CAPOSSELA: Good morning, Bill. We're going to take a quick look at the Zero Admin kit for Windows NT 4 Workstation. It's going to be available next month for free download over the Web. Let me just tell you what we're running on here. We've got a laptop running NT Server 4.0 and we've got a Unisys box which is actually shipping right now, and that's running NT 4 Workstation, and it is very close to meeting the Net PC specs. So it's a Pentium 100 with a hard drive in there. It's got a very small form factor.

MR. GATES: That's small.

MR. CAPOSSELA: The network is built right in. So let's take a quick look here. The Zero Admin kit obviously tries to make it very easy for people to fully manage desktops, and we're going to see an example of that. I'm going to log in as a particular user, NT 4 here. Now, this user is what we call a task-oriented user. They don't need to run a lot of applications. They really do just one particular task, which is perhaps taking orders or doing customer service on the phone. Once we're finished logging in, you'll see what's happened here. Without us having to do anything, a particular application which the administrator set on the server, automatically runs for us. The administrator has total control over the desktop, so you can see that they've made this desktop extremely simple for this particular task-oriented user. There are no shortcut icons. You don't see "My Computer" or "Network Neighborhood." There's no task bar down at the bottom, no Start button, nothing at all. There's just the application that the administrator has chosen to select for this person. It could be a VB 5 front end. It could be a VC front end. In this case it's IE.

Now, you'll notice, if I go ahead and try to shut this application down, maybe to try to do something else on the machine, you'll see that without us doing anything, after a few seconds it's going to come right back up in our face. The administrator has total control over this desktop.

MR. GATES: That works great if all you want to do is run one application. But some people need a little bit more flexibility without being exposed to the full richness of the system.

MR. CAPOSSELA: Exactly. If we go ahead and log off, give us a second to shut down, we're going to log on as a different type of user, and the administrator has set up privileges for that user slightly differently. So let's log on. And again, we're logging on to the exactly same machine.

This is what we call the Knowledge Worker, if you will. The administrator, again, gets to choose what applications they run and gets to choose how their desktop behaves. You'll notice once again there are no shortcut icons on here. There's no "My Computer." Right-clicking doesn't work. But the task bar is there. And if we click on the Start button, you'll see that we've got a list of applications under our programs menu that we can run. And again, this list of applications is controlled by the administrator. There's Word, and I can go ahead and launch IE and that'll bring up the exact same application that we were looking at. So if this user wants to work with multiple programs at the same time, they can certainly do it, but it's still in a very controlled fashion which the administrator manages.

On the Start menu, under Programs, we've got Excel and IE and Outlook and Word, but we don't have PowerPoint. Let's switch over now to the server machine and see how the administrator can make this change for all the users that fit in this particular group. This is just an NT group that that particular user fits into.

MR. GATES: Yeah, let's go ahead and give them PowerPoint.

MR. CAPOSSELA: Okay. So here we have PowerPoint right here in our list of available applications, and I can go ahead and control, drag and drop that with the Start menu for all our app users, which is a particular group that we've created. So it's sort of a simple drag and drop here. PowerPoint and Office are installed on the server. When we switch back over to the client machine, which I'd like to do now, and we mouse back over our Programs menu, you'll see that PowerPoint has now been added. [Applause.]

As I mentioned, the Zero Admin kit is going to be available hopefully next month, both for Windows NT 4.0 workstation and for Win 95. It doesn't require a new version of the operating system.

MR. GATES: One of the big opportunities with these new distributed applications is to deliver them through a browser and to have the browser give good performance for data investigation. This is a big theme of what we're doing with Internet Explorer. Internet Explorer 3.0 is very, very popular. But as soon as we got that shipped, which was about nine months ago, we started in on building the next major version, IE 4.0.

There are a lot of big things we're doing here -- some speed-up things, some rich editing things. Perhaps the biggest breakthrough is how we're allowing you to do collaboration and communication with the product. We think that letting you see rich pages and not forcing you to wait for the round trip back and forth to the server can really allow full-blown applications run out of the browser.

This browser is being built into the system, and so the shell that you use to navigate files and messages and all the data on your system will have the richness of the browser. You'll be able to have book marks anywhere you go. You'll be able to have history anywhere you go, and traversing links. You won't have to worry about it if you're going out to the Web or going to some other type of store. That kind of unification of user interface level is very important, and IE really kicks that off.

A final point here is no price increase. We're staying at the zero-dollar price that we've had for the product. [Applause.]

Now, one aspect of this rich collaboration is advancing HTML. We call this Dynamic HTML that Internet Explorer 4.0 is able to support. What that means is that there's a lot of rich information that comes down with the page, and you can use the richness of the browser to let you see that in different ways. The best way to understand this is to actually see it running, and so I'd like to ask Tom Johnson, who's a product manager for IE 4.0, to come on and give us a little look at what we mean by Dynamic HTML.

MR. JOHNSON: Bill, what we're going to talk about is Dynamic HTML, which provides a way for developers and authors to control the user interface on Web pages. Developers are familiar with the object and event models that we provide for them in Visual Basic and in Access, and we're extending the rich object and events model now to include Web pages with Dynamic HTML.

For example, as we review these elements of the Web page, Dynamic HTML is picking up the events and automatically updating the page, in this case the style of that word, to reflect the event, which is fired off a VB script. It can also fire off a Java script element.

All elements of this page are actually HTML, and we can actually update any elements of the page at any time without going back to the server to refresh. One thing we can do, for example, is show some of the neat multimedia effects that we have here in Dynamic HTML, which include these rotating Es, for example.

Another thing that a developer or a content provider can do is provide complete creative control of the page and allow the reader to look at any level of information they want to. So, for example, the author can say, "I'd like my reader to be able to look at in-depth information or at a collapsed level of information," and you can take a look at information at any level of NT the reader wants to. The author has complete creative control.

Now, Dynamic HTML also reflects some feedback that we got from developers. They said, "We want to present tabular data and data-binding to our customers." So we've included that in Dynamic HTML. What we have here is a data table that we can sort, in this case by employee last name. We can filter by sales region. We can go back ahead and sort. In fact, you can even present a current record view so you can look at individual employees in this case, one record at a time. Now, Dynamic HTML is in compliance with the W3C document object model requirements document, and we're working very hard with the W3C to move this forward.

The final element of Dynamic HTML I wanted to show you is some more multimedia features. What we have here is a page where, like every other page, we can update elements of the page, do the mouse-over event, but we can also fire off events which move this fish around. The fish is animated GIF, and by clicking on the page, you fire off sound events and you set a path on the fish that moves it from one side of the page to another. And we've set this up so that it takes a second exactly for the fish to move from one side of the page to the other.

MR. GATES: There's a simple script behind this that's controlling that HTML presentation.

MR. JOHNSON: Absolutely. We have an open scripting model. We support VB script and Java script and any other script that plugs into active scripting. And again, we can update any element of the page at any time without going back to the server. So working with that tabular data control, as we do the resource and the filtering and the current record view, that information was brought down once. We never need to go back to the server to update the page.

Dynamic HTML gives the developer complete creative control over the page, control to modify any object at any time and control the response to events like mouse over, mouse up, mouse down, mouse position.

MR. GATES: So it's a revolution in HTML. Thanks very much, Tom.

[Applause.]

MR. GATES: There are a number of announcements we're making today, and they all fit into the theme I've been talking about, which is Windows as the platform for distributed computing. The first is the commitment by HP and Digital to include the COM support in all their operating shipments. Obviously, as they ship Windows, which are their highest-volume operating systems, they've got it there. But even in their other operating systems, they'll be including that as well. Those aren't the only platforms we have COM on. We've got Solaris versions and MVS versions that our partner Software AG has helped to build, and those are available as well.

Another key announcement is the packaging of the transaction server. Not only will it be available on NT Server, it will be included with NT Server. This is the same type of move we made when we put our Internet Information Server in NT and decided that that was such a fundamental piece for the future that developers should be able to count on it. It shouldn't be an extra-charge item where some copies of NTS would have it and some wouldn't. The transaction server is so helpful to simplify the building of these new applications. We've made it part of the standard model. And so, starting with NT 5, that is now part of the definition of NTS.

We're also announcing something you saw demonstrated here by Jim Drennan , which is the ability of COM to work with other transaction systems. We support the XA standard. But in the case of CICS, we did special work that allows you to have that simple interoperability. And so PC-based applications will find it very easy to call and do CICS transactions. And that just fits in with our whole commitment to interoperability, being able to take the client side of an application and update that, independently of when you go and take the back end and eventually change that around to use PC technology. So the COM CICS capability is something that a lot of people who have CICS systems will want to take advantage of.

The last announcement is the one with the most depth of elements in it. This is an Intranet solution center where we put dozens of Intranet applications out and made those available. These are exploiting the Microsoft platform in a great way, and we'll be making sure there's lots of information for people about how they use this Intranet technology. We want to make sure the road map to take advantage of what we're doing with the platform is very, very clear. And so we'll see lots of people using those sample applications to do real customer work.

So in conclusion, we're taking on a big challenge here. We're taking leadership in distributed computing. We're doing that in a way that draws on all the work you've done to date -- the languages you like, the code you like. But by taking COM to a whole new level, we let you leverage the infrastructure like never before.

This is going to be the basis for the innovation in our tools and Windows going forward. It is the thing that's necessary to really fill people's vision of the Internet as this big transaction environment that everything you're interested in is out there. We're very cautious about developers' needs for the cost platform support in making sure we've got the tools that can let them have the flexibility they want.

We really appreciate the incredible interest and attendance we've got here today. And I think for all of us, this next decade of development will be even more exciting than the last decade. Thank you. [Applause.]