ANNOUNCER: Ladies and gentlemen, please welcome Chairman and Chief Software Architect for the Microsoft Corporation, Bill Gates.

(Applause.)

BILL GATES: Good morning. We have about 6,800 people here today, which is a very impressive number; up from previous years, and I think a real reflection that we're on the verge of something new and very, very important, a new way of writing applications that allow for a flexibility and agility that we've never had before.

So today you'll be hearing about the key tools for this next generation of applications. At every juncture advanced tools have been the key to a wave of applications, and a wave of applications have been key to driving computing to the next level of effectiveness.

With the original PC it seems pretty simple now, MS DOS, Basic, the assembler; the total amount of information about those tools was quite modest.

With the next big wave, graphic interface, we had to learn a lot about tools to make it easy and possible to write those rich new applications. And, of course, that completely changed the way people thought about user interface.

In the mid '90s, of course, it was the HTML revolution, and there the browser, IIS, Visual Inter Dev, FrontPage, all came together as very effective tools for a complete new wave of Web site applications.

Today, of course, we're talking about something different, something that allows programming between any two computers on the Internet, allowing them to take their smarts and their data and interact with each other in a very rich fashion.

So it's about XML Web services, and the key tool here is the one we started work on three years ago, called Visual Studio .NET. We're very enthused with both the progress we've made and the reception that we've had for this work. We consider it the groundbreaking work for the XML wave.

Well, Microsoft talked about .NET and the vision around it several years ago. That vision spoke to the user experience. Instead of having your information be on a particular device and making you be the one who moved it around from PC to PC or up to the PDA or onto the phone, we talked about a vision where the user is at the center and all of that information is automatically made available no matter what device that person is using. So the vision was any time, any place and any device.

Then we talked about XML. XML is the fundamental element that would be the fabric to tie all these things together.

Well, now we're showing how around this .NET architecture we have the key pieces. First of all, we have the servers, the .NET Servers, we have the services, the key building block services, and finally the intelligent clients: Windows itself on the PC, a subset of Windows on the Pocket PC devices, and likewise on things like intelligent set-top boxes and all the other intelligent devices that will come along and participate in this network. So it's really the strength of these pieces coming together that create the foundation for these applications.

Well, some people say to me, you know, "What's your role in this, do you really believe in this, what have you been up to." Well, I've been very lucky to be able to shift the time I spend very much towards working with our product architects, spending time on the product strategy. I have Steve Ballmer as our CEO and so I get to spend about 80 percent of my time being Chief Software Architect. It's kind of an unusual title, so I've put together a little video to give you a sense of what it's like to be a Chief Software Architect.

(Video presentation.)

(Applause.)

BILL GATES: So it's tough work. (Laughter.)

So .NET depends on three big bets: A big bet around XML, a big bet around a new platform, a platform with smart clients, rich servers, connected by a number of services that are always available out in the Internet, and finally these applications, when you get onto the device, have to tailor their appearance and their richness to that device. And on the device we need a level of richness and ease of use that we haven't had before.

We're not just talking about taking a browser and pointing this at a single Web site where you can read the information by turning the device into a terminal; we're talking about an environment where information from all systems on the Internet can be gathered together into a rich view and the involvement of the user, their creativity, their annotation, all of those things get involved in interacting with that application. It's a vision that includes peer-to-peer as part of the design. It includes the ability to work offline with that information and have the information automatically synchronized with all the other devices as soon as you're connected.

So it's a big change from that HTML approach. The HTML approach will continue to exist. It's very important as a class of problems that it works quite well for. If you simply want to present information from one Web site and have the user read that information, HTML is the right solution. But if you want to program the Web, if you want to treat every one of the devices -- servers talking to servers, servers talking to clients -- as having intelligence and being able to exchange data in a very flexible, heterogeneous form that includes enough self description or schema that allows the applications to adapt to that data, then XML is the key standard.

And, of course, you're all aware that XML itself is simply a starting point standard. It's really the things that have grown up around XML, particularly the SOAP related standards that are now turning it into the fabric for distributed computing.

XML, of course, is not particular to any platform. All the work that we and other companies are doing to push these standards forward simply advance the industry. In the same way that we evangelized the idea of graphics interface, that was something that showed up on every single system.

Within XML platforms will compete to be the best implementation, to have the best price performance, the best scalability across multiple servers, but XML itself, the beauty of it is that it's an open standard. It's also a standard that doesn't force people to completely rebuild their applications. We have fantastic examples both of people building from scratch around XML, where you get 100 percent of the benefits, but also very strong benefits from taking and putting XML layers on top of existing applications and allowing that to be the way that you get interoperability or integration between the applications.

This is true across corporate boundaries when you're exchanging information but even inside companies where you're trying to stitch the pieces together, XML has proven to be a very, very powerful tool.

For example, when the UK government wanted to present to their citizens a single unified view, they knew they didn't have the budget to go back and write the social security system and the tax system, but they knew they needed to make all of those things appear without showing the differences in the underlying system.

And so literally within a few months of work they were able to take and build XML layers around those applications and create a user interface, a portal, a government portal that was more sophisticated than what other governments had done putting out literally ten times the time and the investment in building those applications.

XML is about distributed computing. In some sense you can say that this has been a dream of computer science for many decades. Well, finally it's a necessary dream. These are the set of standards that are absolutely required to support things like e-commerce, the ability to have rich interactions between businesses where the people at both ends have never coordinated their design and, in fact, they don't necessarily trust the execution environment of the other company, and yet they're able to find products, they want to do transactions around, they're able to orchestrate extremely rich flows of information back and forth, and all of that happening without any special glue code that relates to that particular connection.

There is very broad industry support around XML. The good news here is that we really have no doubt that this bet will pay off. When we got started in 1996 taking SGML and reshaping it to a standard that went beyond structure checks to something that would be used for data as well, in those days it wasn't a very mainstream activity. But particularly over the last few years as IBM and many other companies have joined in and said, "Yes, this is the direction that things need to go in, our customers really are demanding these new types of systems, this level of interoperability," the momentum is there to drive this to the same kind of central position that graphics interface or HTML had across all the different systems in the past.

And so the people here, all of you are pioneers driving this forward, but it will come to be accepted as sort of common sense. Of course you can reach out to other systems, find out what their capabilities are, in a very secure way prove who you are and what your rights are and exchange rich data and keep track of the exact state of these systems. So they're not only rich, they're also easy to understand and very debuggable as well.

So this will change the world of applications quite a bit. The idea of componentization now can really be thought of as profoundly built into the architecture of the system. The way that these components interact using XML across system boundaries or across corporate boundaries, those same principles will be used to have components interact within the system itself. Now, that's a special case where, of course, the plumbing will make sure it's done in an extremely efficient fashion, but you ought to think about being able to place the components wherever you like, wherever it's most appropriate for those things to execute, and the kind of self discovery and exchange of information is common because of these XML standards.

In the same way that the application moves away from the single client to be able to be invoked across any client on behalf of the user, likewise the applications move away from being tied to any particular server. Because these applications have to scale up to meet demand that may be unexpected and because they have to deliver an incredible level of reliability, it's absolutely imperative that they be able to run multiple instances across different servers. And by using these messaging paradigms the ability to have one server take over any piece of work that a server that's no longer operating was in the process of doing, that becomes very straightforward. The very architecture of the application allows us to have this transacted capability that allows for the reliability of the multiple servers.

This kind of approach to get reliability and scalability, of course, used to be a niche capability. Systems like Stratus or Tandem had it and that premium was paid to have this for online, 24-hour a day systems.

Well, here with these new applications that kind of capability is designed in. And so as they run on top of the Windows platform, you can say, "Okay, depending on the demand, we will scale this across multiple servers." You'll even have the concept of saying, "If I have a peak in demand, I can look for servers that are available on an on-demand, pay-as-you-go basis and migrate an instance of the application over to those." It takes the concept of peak loading capabilities and disaster recovery capabilities to a new level, because the set up and migration is done using the same rich protocols that the applications themselves are built around.

The kind of data exchange we'll have between companies, taking the paper bill and making that a rich XML document, taking the shipping process and being able to have events that time out that say, "Well, I was supposed to receive this; what happened," or, "I received something; it wasn't what I expected," the ability to define all that in a very explicit way and make sure that it's not just the back end systems that are involved in these rich flows of information.

We think that every piece of software is revolutionized by XML, Windows itself in a very deep way, our SQL database product, which has a very rich layer of XML on top of it today, the current work we're doing for the next generation is actually taking XML down to the very core of the database, making it the central way that the database deals with information.

Likewise for Microsoft Office, we want those knowledge workers, the front office workers to have complete visibility into these XML exchanges. And so Office needs to be able to present XML documents. It needs to make it easy to create templates, XSL type templates. We need to make it easy to take the workflows, the orchestration done here and actually use normal tools to have rich views on those and change what the information is doing.

And so you get rid of the impedance, the mismatch between the way information is dealt with by the knowledge workers and the way the back end systems deal with it. By having a rich enough expression to capture everything the back end needs and everything the front end needs through XML, then you take away that separation.

But that is a fairly profound change. It means a product like, say, Excel in the Office suite instead of working just with a 2D grid needs to have these XML schema capabilities built into the heart of it.

And so XML is affecting everything at Microsoft, not just our tools and our platforms but the very applications themselves and the way they deal with data.

We're very big believers that the user experience we have today can be radically improved. After all, the advance in user experience really the last big milestone was graphics interface. Since then we've added things on, new tool bars, right-click, a lot of things that have to do with that graphical canvass and letting you navigate it in rich ways.

We actually have sort of two experiences in the Windows environment compounded today, the browser experience where you have your history and your back and your forward, and for the read only type world it's very nice, and then the applications themselves. But that division should be eliminated. The ability to have history, go backwards and forwards, that should be in all the applications. And the boundary between a rich client app and actually browsing a Web site that's using code on the local machine, that boundary needs to be eliminated.

The key to this, of course, is making the deployment of code to the client completely hand free, completely a simple thing, so that the tradeoff that's existed for having things be purely browser based versus having them use the richness and get these offline capabilities, that tradeoff goes away, and so you have no cost in the deployment.

In this next decade the way that we use the PC, the way that we use digital approaches will expand very dramatically. You know, during the last decade, for example, the move from presentations being something on slides that you print out or view graphs that you have the overhead to now a common sense understanding that it's a live PowerPoint presentation directly projected, you know, that develops only over a period of years. Likewise, there are many things that the PC environment can do in the future that we don't think about using it for today.

The two areas that are somewhat developed are productivity software and communications. Even here, take productivity, the way you do forecasting, we don't have models around XML. We don't have control over our documents. If we want to send out a piece of mail and say that's only available for 60 days or only to a certain set of people, the whole idea of digital rights applies equally to knowledge worker documents, and that can be built into the system and made very rich.

In the area of communications we still have multiple e-mail addresses, phone numbers, no unification and really no control over when we're interrupted. We don't have an agent or a piece of software that works on our behalf that decides depending on what we're doing and what device we have whether or not we should be notified. We don't have real time communication other than voice communication, but real time where you can use these screens and put up documents and work on them together, having that be a central way that we work.

In the area of reading it's long been a dream that the digital device would be comfortable for reading long documents, and yet today even the most avid user finds themselves printing out that long enclosure. For forms, for the encyclopedia, yes, the digital approach has won out, but for typical reading the screen has proven to be inadequate. It's actually inadequate in two different ways -- the resolution and the way text is presented, but also the form factor. When the screen is in a fixed position, it's fatiguing to read from that fixed position for a long period of time. So we need to not only up the resolution and use special software for the rich layout and the ClearType to get that crisp presentation, we also need to move the screen into a form where you can take it and hold it in your hand. We'll talk more about that today, because we are literally on the verge of that advance.

But imagine how much difference that makes. It means that all the things that you get in the way of reports, information, even a newsletter or a magazine, you can take them, write a little note on them to send that off to some other person, and track exactly what you've read and what you've done with it so that the richness of the digital environment, where you can browse into links and have more than just plain text presentation, that becomes a standard for all different kinds of documents.

Taking meetings and actually having what we call a ring cam, a 360 degree camera reporting what goes on, so that that information can be browsed and searched later on, that today seems like a wild idea, and yet the cost of storage for that is only a few cents. The cost of the peripheral is very low. And so we just need to build that into the user interface and make that very straightforward.

Business solutions around XML, well this is the dream of e-commerce. And we've really just splashed the surface on this. Most of what's gone on today is the purchase order itself has been put into a digital form, but not the rich orchestration, not the rich set of processes that go on, and so those continue to be characterized by phone calls and faxes and mismatches between the back end exchange and the knowledge workers and how they work together.

On the consumer side, you know, will we have digital photos and digital music as the standard way of working, just a common sense approach that lets you transmit and organize in better ways? The answer is absolutely. We're literally on the verge of that today with the peripherals and the software making great advances.

Further, we'll be able to take wireless networking and project information out, so that throughout the home environment, wherever you want to get music or pictures, you can have just a simple screen and the PC will project out to the screen, to the speaker and create a rich environment.

Graphics is moving up to a new level. The kind of entertainment software around the PC and the Xbox are really going to be phenomenal, but they'll also be online where you can talk to people, spectate and play together, because broadband is really coming.

And all of this needs to be put together in an environment where the basic security and reliability of the system is at a higher level than it is today. In this digital decade we need to make sure that as you install a new application, it doesn't affect anything else, and that application is constantly getting better. That kind of infrastructure making that standard really is our highest priority, because it's what enables all these other incredible scenarios to come together.

Well, where are we in this? You know, is it a long time before these things come together? And the answer is absolutely not. In the case of XML Web services it's such a natural way of doing things that even with the early SOAP toolkit and now the beta of VisualStudio.net, we've seen literally hundreds of people pick up on that and do this kind of work. Some of the Wall Street firms, where they had thought through the need for this type of architecture, they were literally sort of building their own SOAP-like environment and we're very pleased to see that we and other companies were saying, "No, this needed to be the mainstream and we'd build tools around it." So lots of Web sites already seeing the benefits of the Web services and able to contribute to the evolution of the protocols to make sure that we're getting these things absolutely right.

Well, the best way to give you a feel for .NET is to take the person who's really been a central architect driving this forward and I know no one is more excited about the fact you're going to get these tools in your hands, so let's welcome Anders Hejlsberg to the stage to give you one lap around .NET.

(Applause.)

ANDERS HEJLSBERG: Thank you, Bill.

I'm going to give you a brief demo of some of the incredible capabilities that this new platform brings to you. I'm going to show you how to build a Web service using ASP.NET, then how to test that Web service using your browser, how to add some data logic to the Web service, how to build a Windows rich client front end for the Web service and finally how to deploy that rich client or smart client using the zero touch deployment feature of .NET. And I'm going to do all of this in about 15 minutes.

So without further ado, and to show you also that there are no strings attached here, I'm going to start out by simply creating a Web service using my favorite tool, Visual Notepad. So we'll fire up Notepad. And I'm going to type in my Web service here. Now, you, of course, know that ASP.NET gives you the ability to create Web sites with HTML pages, but you can also create Web services simply by adding a single file to an existing Web site. You can expose your business logic of that Web site as a Web service.

So we'll start off here saying we want to create a Web service and we'll say "language equals." And since the .NET framework is a multi-language platform I could take any one of a number of languages here -- VB .NET, JSCRIPT, C# or even languages from third party vendors such as COBOL -- now, you'll know that I'm a little partial here so I'll pick C# and I will say that the class I'm going to write is called "My Service." And that's all the instructions I need to give to ASP. Now all I need to do is write the actual C# code.

So we'll say, "using system.web.services" and then we'll say, "public class" and we'll call it "My Service."

And now I'll create a simple add method that can just add two integers. So we'll say, "Public int add, take int X and int Y" and we'll just return X plus Y.

And that basically is all the coding I need to do. Now, I also need to give one instruction to ASP.NET that I want this particular method exposed as a Web service, so I will add a Web method directive to the code.

So let's save this and we'll simply put it into the root of my Web server and call it Demo.smx.

And now let's try to fire up the browser and we'll go hit the URL of local host demo, demo.smx. And here one of the wonderful things you see here, of course, is that ASP when I hit a Web service compiles the application or the Web service that I just wrote, and if there are any errors it will tell you what my problem is here. So in this particular case here I forgot to put a little app here, so we'll simply try to refresh the page.

And as I said first of all ASP compiles the Web service I wrote, then it realizes that the request for the Web service is coming from a browser, not from a SOAP client, and so instead of sending XML SOAP back it sends back an HTML test page that allows me to test the Web service. So here you see it has analyzed the Web service I wrote and it has figured out there's an add method, and simply by clicking the link here I can no test my add method, so I can enter the two parameters for X and Y. So, say 10 and 32 and press enter and invoke the Web service and here you see the result coming back as well-formatted XML, the result is 42.

Now, if we go back to the test page here, you'll see that not only did ASP create a test page, it actually also took a closer look at my Web service and discovered that I haven't put the Web service into an XML name space, which is the convention that you ought to do when you write a Web service, so it explains to me what the problem is here in the text, and then it suggests a fix for the problem. And I'm simply going to then copy and paste the suggested attribute here, go back to my code and paste it in like that.

Now, when you write Web services, it's, of course, a little silly to do arithmetic operations over the Web. It's more likely your Web services are going to access data, do some data manipulation and then return that structured data.

And when I look at how people write applications on middle tiers that deal with data, they tend to sort of fall into two camps of architecture. One is modeling the data with objects. You'll have a customer class, an order class, invoice and so forth. And then there will be code in the middle tier to populate these objects, do operations on them.

Another methodology is simply to have more of a table view of your data and you're just using ADO.net and record sets or in the case of the new .NET framework data sets.

So I'm going to show you how you can do either of those two very easily with ASP.

And first what I'll do is start out adding a contact class here. Let's say I want to write a little address book Web service that can return me an array of contact information. And to save you the agony of seeing me type, I'm just going to paste this in. Here's a little contact class that has a name, address and a phone number and a constructor, and then I'm going to grab a piece of code that implements a little Web method called "get contacts" that returns an array of contacts. And instead of going out to a database right here, I'm just going to instantiate an array of five elements.

So let's try and save this. Let's go back to that Explorer and let's refresh our test page. And you saw a couple of things happen here. First of all, the error diagnostic went away because I've now put my Web service into an appropriate name space. And second, I get an additional link here to the "get contacts" method and I can click on that. And since the method takes no parameters, I can invoke it simply by clicking the button.

Now again let's pause here and look at what just happened. You saw me manipulate objects. Here you see those objects turned into XML, completely automatically by the .NET framework. You see that for each of the fields I have in my object -- name, address, phone -- our automatic XML serialization creates a sub element for each of those fields.

It's important to note here that there was no extra work to do this on my part. The .NET framework can take an object, turn it into XML, round trip it over the wire, on the other side take the XML and turn it back into objects. XML is deep in the fabric of the .NET framework.

Now let's just for sake of argument say that someone had told me the schema of the XML that they wanted to see come back from this Web service, and indeed they told me, for example, that they didn't want sub element for name, address and phone number; rather they wanted attributes in the contact element. I can actually control the shape of the generated XML.

So let me go back to my little Web service here and let me first bring into view system.xml.serialization and then let's go back to my class here and now I can add a few attributes to my class that specifies that for this particular field here, the name field, I don't want that exposed as an XML sub element; rather I want it exposed as an XML attribute with the name "name" with lower case, and we'll just do a little bit of copying and pasting here. And let's say the address, I want that called "adder." And let's say for the phone number I actually want that to be the ID of my element.

And I'll save the Web service. I'll go back to the result page here and I'll simply refresh the results page and you'll see that the shape of the XML changes according to my direction.

Now, as I told you a little earlier, there are sort of two styles that you typically use when you operate on data. One is the object style. The other is simply using database tables. So let's go back to our Web service and add a few more lines of code to it. We'll import the ADO.NET name spaces and then we'll paste in one final method for our Web service here, called "get data." And as you can see, "get data" is a simple method that takes a query string and returns a data set. And in the code here I simply create a connection to my North Wind database. I create an adaptor on that connection with my query string, and I use that adaptor to populate a data set that I create, and then I return that data set.

So let's save this, go back, refresh our test page, and now you see a third method shows up. We'll click on "get data" and we'll type in the query, "select star from customers" and we'll invoke it.

And what you see coming back here is the result set formatted as XML. And, of course, there are a bunch of records here with the actual data, but one other thing you'll note is that the schema for the data is included in the results as well. So this is basically a self-describing packet of XML that contains not just the data, but also a description of the shape of the data, so whoever receives this will know how to format it.

Now, that completes my little Web service. What I'll do now is get rid of the browser here, and then we'll fire up Visual Studio. And now I'm going to show you how to build a smart client front end to this Web service that consumes the data from the Web service.

So we'll start a new project and we're going to pick a Windows application. We'll call it "client." And I'm going to use the Windows forms designer to build a little front end for the Web service. So I'm going to go to the toolbox here and I'll grab myself a data grid and a button, put the button down in the corner.

Now, as I said, in this application I'm going to call my Web service, so I will add a reference to the Web service. I'll go into the Add Web Reference dialogue. And, of course, if my Web service was real and in production, I would have deployed it to UDDI. I could directly browse to the UDDI directory from my Add Web Reference dialogue. Now, in my case I'm simply going to hit my local host Web Server and request the Web service description language file for the service I just created.

And what you see happening here, here you see the text of the file and you'll note again that with zero work involved on my part to create this Web service description, it simply extruded by ASP.NET by applying reflection to the code I wrote and then emitting the correctly formatted XML.

So all I need to do is just simply say Add Reference.

Now, what happens when I add a reference is that Visual Studio creates a little proxy class for the Web service that allows me to treat it simply as an object that has methods.

So let's take a look at that. We'll add some code behind the button here. And since I didn't give a specific name space to put the Web service into, it simply is referenced off of local host. So I'll say, "Local Host .My Service, S equals new Local Host .My Service," and I've now created an instance of the proxy class. Now I'll say, "Data grid one .data source equals S." and now I'm referencing the methods of my Web service and you'll see that I actually get statement completion those methods. Right here you see the Get Contacts and the Get Data method, and indeed it even knows that Get Data takes a string called Query, so I'll type in again the same query string, "Select star from customers." And finally since datasets can return multiple tables, I will simply take the first of those tables in the data set coming back.

And that completes my code. I'll now run it. And here you see my little smart find application running. And now when I click the button I will call the Web service. The Web service will send me back some XML that I'll put into a dataset and then populate a data grid from that XML.

(Applause.)

Now, of course, the job isn't done until you've actually deployed this application to the, say, 2,000 clients that you have in your enterprise, and I'm going to show you how to do that using the zero touch deployment feature of the .NET framework.

So I'll shut down this app again and what I'll now do is I'll go to the properties page of my little project and I will change the build targets to be the root of the little Web site in which I have my Web service, which is my demo directory, and then I will simply rebuild. And yes it built.

So what we will then do is we will fire up Notepad again and we will type in a little Web page that links to the executable that I just built. So we'll say HTML, and so you can see it will do H1, and then we'll say, "click create an H ref to client.exe," so, "Click here to run smart client application," and close off our H1 and close off our HTML. And let's save this and we will call this one Start.HTML.

And let's fire up the browser again and let's hit localhost\demo\start.HTML, the page that we just created.

And here you see what the user would do to deploy the application is they would go to this Web page and they would simply click the link to client.exe. The client then gets downloaded into the Internet cache and you're now running.

Now, one thing you'll notice though is that -- and, of course, well let's just see that we can indeed hit the Web service. Now, one thing you'll notice here is that we did not get any kind of warning dialogue or security dialogue that says, "Warning, do you want to run an executable." The reason is that this executable that we're running is actually running in a secure sandbox and there are whole lots of barriers around it as to what things it can actually do. And to prove that to you, I'm going to close this thing, go back to my project, and I'll add an additional button to my little application here. I will grab a button. And in this button we're going to write a line of code that would not be permitted by the security system. So, for example, we will say something like system.io.file.create and we will try to create a file called log.text in the root directory of the machine on which we're running.

So let's save that. Let's rebuild. So we are now rebuilding into the root of our Web site. We'll go back to the HTML page. We'll click the link again and you'll note what happened here was that the Web Server noticed that there's a newer exe in the directory and it re-downloaded that executable into the download cache on my client machine, and now of course I can still talk back to the Web service, since I'm talking back to the same URL that I came from. But if I try to create a file in the root directory, I get a security dialogue that says you can't do this; you're running in the sandbox.

So what you've seen me do here in 15 minutes is use ASP.NET to create a Web service, to test it from the browser, to add data logic to it, to create a smart client for the Web service and finally how to deploy that smart client. And, of course, the thing that makes all of this possible is .NET, and that's what this whole conference here is about.

So thank you very much.

(Applause.)

BILL GATES: All you need is Notepad. (Laughter.)

Well, a great milestone that we've achieved for this conference is what we call the release candidate for Visual Studio .NET and the .NET framework. And those are included in the many gigabytes on the six CDs that you have.

What this means is that we think we're ready to go. Any last minute feedback you have we want to get. We feel we're definitely on track to go final with these bits before the end of the year.

It's been a long road to get here. Many of you have helped. 3.6 million cans of soda, that's a lot, and pretty incredible beta participation, not just in terms of the breadth, the 2.5 million, but in terms of the depth. And inside Microsoft it's been interesting to track this. A lot of products, new platform things, I really need to go around to the different groups and just say to them, "You've got to do this, it's part of the task, please use this new thing." It hasn't been that way with .NET at all. In fact, one group had used it and shown what their productivity had been like, what the efficiency of their Web site was and the kind of agility they had, the ability to do new things with that Web site. It really caught on in a very big way, and before we knew it, a very substantial portion of all the new things we were doing on the Web were using .NET.

So we've had some of these now for over six months -- Music, e-Shop, Yellow Pages, Office update, UDDI -- so every new thing we're rolling out on the Web we're using this, and the fact that in some cases we need to write new code for this, the payback time on it is literally months.

So this is the fastest, most bottoms-up developer phenomenon that I've ever seen. And that's a very good thing. It means that the learning is happening very, very rapidly.

Well, part of what we're talking about here is the ability to use the intelligence of the client. And we really have to say that this bifurcation to where we had client-server, where you deployed code to the client and pay the price there, and then this pure HTML approach, we gave people a painful choice. There really was no good answer between those two. And part of that was we didn't have the security framework, we didn't have the automatic deployment, we didn't have the side by side execution capabilities that meant that things would come down automatically, and so people felt torn between these things.

You know, there were even people who said, "Hey, the future is networked computers, dumb devices and put it all back in the center. Forget about offline. Forget about latency. Forget about the rich interface. Forget about where we're going with speech recognition, handwriting recognition." And those are serious caveats, but it was all done because the perceived cost of this deployment meant that people were moving away from it.

So now with the next generation client we want to solve that. We've moving up in terms of the interface the role of animation, video, the role of these new input techniques. Those will be clear to people in the next few years, the idea that offline is important, that using as much computation at that level is very good.

These new networks are great, but their latency, the latency of the 3G networks is on the order of a half second in a fundamental way, so that the idea that you're paying round trips again and again, say, for every click or keystroke becomes increasingly painful. We saw this with these WAP phones, where people really looked at that and said, "It's just not rich enough; the kind of local storage and interaction I get off of that makes that an unacceptable experience." So it's the smarter devices, Pocket PCs or o-mode approaches where you really have a lot of intelligence in the device that have been successful here.

Of course, the key client is going to be the full-screen client. Smaller screen clients are very important, but contrary to what some people have said, they're not substitutes. In fact, the people who will really drive those small-screen clients are people who use full-screen clients. And the scenarios in the .NET spirit are across both. You might plan a trip on the full screen and be notified of changes and updates when you're just carrying around your small screen device. Major things like homework, tax returns, business analysis, major purchases, of course you're going to want that full screen capability, but then you want as much access as possible off that small screen.

So Windows XP is about the full power of the PC and it represents a very big milestone for us. You know, those of you who have come to PDCs for many years know that we've been talking about taking the so-called NT kernel and having that in every version of Windows. We talked about that being important so that when you develop your applications you can look at the rich capabilities there, the performance characteristics there, the error recovery capabilities that are built in there, that device driver people can just focus on one area, one model alone.

And so we've been pushing towards that. It's been a huge, huge effort to take the code base and have it really be capable in a very compatible fashion running the classic Win 9x environment.

And so here we've achieved that. On Thursday we have the official introduction. I'll actually be flying back to New York for that. The mayor of New York when I talked to him about should we come back, should we do it there, not only was encouraging to say, "Yes, this is great, it's a big event, we want you to be here," but he'll be part of the kickoff there so we can acknowledge the amazing things that New Yorkers have done and in particular the mayor's work there as part of that Windows XP event.

(Applause.)

This is a big advance for Windows. The broad set of features is pretty long, but ease of use, reliability, performance, the XML things built in, those are probably the primary elements. We will look back on this release of Windows not only as where the NT capabilities got everywhere, but also this is where real time communication is now there for your applications to do neat new things. This is where Windows Update, the idea of constantly fixing both the platform level and the apps really got built in, and it's also where we built in a lot of solution type capabilities, the photos, the music, the video, the kind of help things, sharing the screen and helping someone out, a lot that's built in.

And so this new version of Windows will be on virtually every new PC by the end of the year. We've got the home version, the professional version and that is appropriate literally for every client, particularly because the price of memory has come down to where the 128 meg requirement here is not such a burden in any form. In fact, we think a lot of systems will be at 192 or 256.

Likewise, Windows XP will be a major upgrade phenomenon. Anybody with enough memory, this is a pretty clear upgrade for them. And so the total install base of this will be very, very large in a very rapid way.

Let's quickly take a look. I'd like to ask Kyle Marsh to come out and just give us a quick whirl through XP really from the mindset of the developer.

(Applause.)

KYLE MARSH: Thanks, Bill.

As a developer, I'm very excited about Windows XP for three big reasons. First off, Windows XP is the best platform to use to developer software.

Secondly, the reliability of Windows XP is going to be great for my users.

And third, XP lets me add some great new features to my application with very little development cost.

Now let me show you a couple of ways that Windows XP is going to make me more production.

So here you see my system setup, and what I have here is fast user switching, which is actually a developer tool. What I've got is my different test case scenarios, the different settings that I need to test my software under set up as different users. Now, I am using the multi-language user interface pack so that I can have a different language for each user, and I'm going to use a fingerprint reader from Digital Persona to make my user switches very fast.

So what I have is I've set it up so that each of my fingers represents a different test user. (Laughter.) So if I want to make sure that my dialogue boxes are big enough to handle the German language, I can quickly switch to my German test user. If I want to make sure my software is accessible and can be used in high contrast, I can switch there. And of course I want to be able to sell my software in the Asian market, so I'll always have a test case there as well.

So it's very easy to switch between my different test cases. The great thing is I can switch right back to my development environment and all my tools are running just as if I'd never left. Everything is up and running, my e-mail, everything.

(Applause.)

So another way that Windows XP is going to make me more productive is with the remote desktop connection ability. This is built in to every client of Windows XP, and Windows XP Professional allows me to access my machine from anywhere on my network.

So I'm going to go ahead and connect to one of my development machines. This can be anywhere on my network and, of course, physically anywhere it needs to be. My office at Microsoft with its great Internet connection and everything is a great place to have that box.

So here I can completely access all of my developer tools, I can test. So this is going to help make me a lot more productive, because I'm going to launch my hour build when I leave the office, and as soon as I get home check to make sure that it hasn't died five seconds after I left the room. So this is going to help really push my productivity.

I can also use, of course, multiple of these at the same time if I want and run them in a window. So if I have lots of machines, I can go ahead and do this. It saves me sliding my desk chair all the way down the end of my desk.

So the next great thing about Windows XP on top of the productivity is the great reliability that's really going to benefit my users. Windows XP is even more reliable for users than Windows 2000. But there are some great things that are going to let me make some really big steps forward in the reliability of my software.

So the first thing is I can use side-by-side assemblies to isolate my applications so that for my users DLL hell will be a thing of the past.

So let me show you an example. We have this grew new visual style in Windows XP that naturally requires a lot of changes to some key system components. If we had developed these the old way, there is a possibility that a lot of applications might have broken. But instead we have used side-by-side assemblies to isolate applications from these changes.

So, for example, I have here just a regular application, and I'm going to go ahead and launch it. And you can see that this application has been isolated from the full effects of the new visual style. There is no hot spotting. The controls are rectangular. It has the old look because it's isolated from them. All I need to do is provide a manifest, an XML text file we call a manifest for my application, which tells the system that my application worked with the side-by-side version of these components. Now I simply launch the exact same executable file, untouched, but with the presence of a manifest I see that now my application completely uses the full new visual styles, and my users benefit from this great new look and feel. So it's very easy to incorporate the new visual styles into your applications and you can use side-by-side assemblies to isolate your applications and make them rock solid for your users.

(Applause.)

Another great way we're trying to increase the reliability of not only the system but of the entire ecosystem on the PC, including all of the applications, is with system side error reporting. So what happens is when I have an application like this little test app that causes an unhandled exception by any place on the system, whether it's an application or the system itself, the user will be presented with this new dialogue box.

Now, the key new feature here is the Send Error Report button. Lots of users will click on that Send Error Report. We've already been getting a whole bunch through our beta testing.

What we will do is obviously if the crash happened somewhere inside of Windows, we're going to want to fix that right away. But if it's a problem inside of one of your applications, then we want to help you to be able to find and fix these issues.

Now, the problem is we don't actually know who to send these reports to, so the way you're going to do that is by registering your application in the Windows catalogue. You simply register your application as a compatible for Windows XP application or better yet designed for Windows XP, and if you do, then we will be able to send you any error reports that come our way.

So this is not just testing, but real world data on how your application behaves for your users, and it's going to be really able to help you target and focus your developer resources on the most important problems that your users are experiencing.

So the third great thing about Windows XP is the great feature that I can add to my application for very little development cost. So one example of this is something called our Background Intelligent Transfer Service. So I'm going to run the BITS sample straight out of the SDK. It adds this "Background Download As" item to IE's context menu, and then we go ahead and start up a transfer here.

So what happens is we automatically start sending these in the background. We use BITS to drive our automatic updates. So when we get an error report from the fault reporting up to Microsoft and we notice that there's something we need to fix, we automatically update the user's computers through BITS. And we do this only using the background bandwidth of their connection. So when they're not browsing the Internet, we're sending their updates down.

But BITS can handle more than just that. If by some accident, my connection was somehow disturbed like someone accidentally pulled out the network cables or they turned off their machine or for whatever reason the transfer was stopped, then the BIT Service will automatically suspend my transfer and once the connection is reestablished it will be able to restart it for me.

Now, in the interest of time, this sample actually takes a little while to notice it automatically. I'm going to give it just a little kick by hitting the Suspend and Resume button and you'll see the transfer picks up right where it left off. This can be a very hand thing so that you can close that error reporting/bug fixture loop in the same way. When we help you find the places where your application has problems, you can use something like the BIT Service to send automatic upgrades down to your users as well.

(Applause.)

So the last quick thing I want to show you is real time communications. So we've added, as you know, Windows Messenger, and that same infrastructure that we use to give that really rich communications experience within Windows Messenger is just an API call away.

So let me start up a little Win form sample up here and what we're going to do is we're going to simulate just a quick video session with Bill's machine. So here I have a sample and we're going to make a client RTC, a real time communication control available later this week up on MSDN. So I'll simply go ahead and drag that to my form and go ahead and start the app.

Now, some real value is added by your application, because it's your application who knows who I want to speak with, often when I don't actually know myself. So, for example, I might be a controller looking at an accounting report, and I'll notice that there's an entry I'm not happy about. So I can simply ask your software, "I need to talk to the person who made this entry." Well, your software knows who did that, so your software will go to a server, find out where that person is. He could be down the hall or around the world. The server would come back with advanced presence information and the rendezvous point of where this connection could be made.

We're adding this feature, this real time communication server functionality to all of our Windows.net server products in the form of a fully ship compliant proxy and registrar, and then simply your software will use that information to establish a point-to-point full, rich communication. So, for example, I'll click and I'll see Bill's box: "Hi, Bill." So very easy to add this real time communication directly into your applications.

(Applause.)

So I'm very excited about Windows XP and I hope you all are as well. I know you want to get your hands on a copy as soon as possible. So if you can find a way to come here at the very developer unfriendly time of 7:00 a.m. on Thursday morning to watch the Windows launch event live from New York, then we're going to give you your very own copy of the full Windows XP Professional product for coming in and seeing the launch.

(Applause.)

Okay, so thank you very much and I'll see you Thursday.

(Applause.)

BILL GATES: We've talked about this idea of new interaction and new interface, and that really comes together in the form factor we called Tablet PC. In a sense you can say it's evolutionary. I mean, it's like a laptop without the keyboard. In fact, most of these will ship with a keyboard. Sometimes you'll use it with that keyboard. Sometimes you'll use it without.

The wireless capability that's built in here I think we're all very excited about how that's becoming pervasive. Let me be clear: Microsoft expects 802.11 and its supersets to be present in most places that people spend time. In corporate offices it will be pervasive. In campuses, hotels, convention centers, airports, shopping centers; virtually everywhere this 11 megabit and up capability will be there.

We're doing the work to make sure that there's enough QOS to be able to do voice over these networks, enough security so that your information is secure and you can VPN very easily back to your corporate network. We have a huge commitment to this wireless approach. In the home this is fundamentally the way that video, audio, pictures, applications capabilities through Windows Terminal Server will be able to project throughout the home.

And so 802.11b is a very key element of the tablet, all portable machines and all machines. Even the Pocket PCs you might be surprised we have low power 802.11 for driving that common transport there.

These devices will home to the 802.11 whenever they can. If they don't see the 802.11, then they'll look for a 3G type network, which is more pervasive, but then again the type of packet charges involved there will be far more substantial.

How is the tablet different? Well, it turns Windows XP. It turns every existing Windows application. There is no compromise in that. But this ability to do Ink interaction, Ink annotation, the handwriting recognition, which is really quite amazing, and the way we've built in the microphone capability for speech annotation and speech recognition as well is very important.

We're hard at work in the Office realm on new applications to take full advantage of this, and our partners, the hardware OEMs will have machines out in about a year, the second half of next year.

At this conference, one of the things that's on those six CDs is our software development kit for the tablet.

Let me, so you have a sense of why we're so excited about this, ask Charlton Lui to come on out and give us a quick look of what the Tablet PC looks like and what kinds of things will people do with it. Welcome, Charlton.

(Applause.)

CHARLTON LUI: It's exciting to be here today to show you one of Microsoft's coolest innovations in the pursuit of what we call the Tablet PC. Now, this is a fully functional PC, truly a superset of Windows PC, Windows Professional.

Now, it's everything you expect from a laptop and more. Now, check this out. See how super sleek and thin that is. Well, Tablets will be about two and a half pounds, last about six to eight hours, have wireless 802.11b wireless connectivity, and have great support for hot docking.

Now, as Bill announced, all Tablets will have the .NET framework, which means that it's an ideal platform to develop and deploy your .NET solutions.

Now let me shift gears and actually demonstrate some of the development opportunities you have with the Tablet.

Now, this is out-of-the-box, actually there's a set of development opportunities ranging from insignificant amount of code augmenting existing applications to the creation of a brand new class of applications built specifically for the Tablet PC.

Now, this is actually Corel Draw out-of-the-box untouched, and I want to show you some basic, adding basic support to an existing application like Corel.

First of all, I'm going to go ahead and just launch the Visual Basic editor. Now, I actually made a reference previously, but I'll just show you. There's a reference to the Microsoft 1.0 Ink Library. I simply insert a module and I've actually written some code. I'll just go ahead and paste this in.

Now, you'll notice a couple things. One is there's actually Ink collector objects. Had to get a handle to the document window, enable the Ink collector, and I didn't have to set any drawing attributes, but I wanted to, so I set things like the color, the pen thickness and actually a little bit of the basic curve fitting. And I'll save that all.

Now, as you see, this is just a few lines of Visual Basic code. And now all I need to do is run my macro to enable this Tablet PC feature.

And here we go, and you'll notice I have an Ink acetate layer in existing applications. Isn't that nice?

(Applause.)

So, in fact, this is really a great opportunity for those not only creating the content, but also those who just want to review that normally would do it with pen and paper; they can do it with existing applications.

Okay, I want to switch gears and talk a little bit about what it takes for just a bit more development effort. This is actually a prototype version of Visio. It has one developer of two weeks of coding, that's it, C++. You'll notice that there's actually a pen that's been added to this toolbar, and, in fact, if I tap on it, if I can find it, and you'll notice that there's a set of pens that have actually been designed for this application, plus an eraser and I can actually define pens. I'll choose the default.

Now, this is actually Safeco Field, home of the Mariners -- woo-hoo! (Laughter.) Now, I'm going to have to modify the demo a little bit, because I was going to show you where my World Series seats are, but I guess, well, we'll have to wait for next year. But as many of you know, the Mariners have been selling out quite a bit this year, and so I thought it would great if we could actually just add some seats into the stadium just like that, and add another row here.

And what's great about it is this is actually really integrated deeply into Visio, so I'm able to do things and make this -- it's actually a first-class citizen within Visio, so I can do things like fill. Now, fill exists in Visio, so you can imagine using fill, all the operations that you normally do, all the drawing tools, plus you could actually maybe even use handwriting recognition or even speech recognition to say "cheer" and you could actually find that template and convert it.

And I'll switch to my pen, the red pen and just say, "More seats, please." Voila! So that gives you a good idea of what you can do with integrating a little bit more deeply of two weeks.

(Applause.)

And lastly but not least I'd like to show you something from the ground up that takes advantage specifically of the Tablet PC features. This is actually our note-taking utility that will be shipped with the Tablet PC platform. Now, notice a couple things. Notice how nice the Ink looks. We're actually sampling at 133 samples per second as opposed to the 30 to 40 samples for a mouse. Also we're doing curve fitting with BASEA so it actually looks very natural. And, in fact, here's a page of notes. They look pretty nice.

The thing is Ink is a first class citizen, so I can do things like select this and, in fact, format my own handwriting. Isn't that sweet?

(Applause.)

Other things that I love to do with pen and paper but I can't typically I might add more information right between the margins, in between the words, but I know when I'm going to have to do that I can actually use my handy-dandy space tool and just open up space. (Applause.) This way I can actually make as much paper as I want without killing trees. (Laughter.) Yeah, environmentalists over there. (Laughter.) Woo-hoo!

Okay, I'm going to go ahead and draw a diagram here. What's nice about a computer that I can't do with paper is I can actually just convert that to a nice clean shape. Now, this is actually for my marketing guy out there, marketing sales guy. He loves these kinds of charts, so I'm going to try to see if I can do a good job with it. Oops, actually I'm not doing very well because I'm not spacing it very well. But those are quarters, and I want to set a goal when we ship the tablet and make sure that it has a good goal to set. So I want to make sure that I have this good hockey puck here.

Okay, and one last feature, one of the things I love to do with my notebooks that I have is whenever I try to find the information that I want, I always have to thumb through it, but instead I can use Find. Now, we actually do background recognition, so I can find all the content that I'm interested in, and there it is right there.

(Applause.)

Now, you can imagine with background recognition what is really cool about it is I can actually take this and convert it to text and then re-purpose it into like contacts, calendars and appointments, and you can imagine the power that this will give you with your own handwriting.

Okay, that's a wrap. This gives you a little glimpse of what the Tablet PC will bring to you. I believe that there's a great business opportunity for you to drive software upgrades through differentiation and innovation, and please check out the breakout sessions of the Tablet PC to learn more details of how to develop for it, and I look forward to seeing your innovations in the near future.

Thank you very much.

(Applause.)

BILL GATES: The interesting thing about the tablet is it takes a lot of things that were growing to be important on the PC anyway, the idea of voice annotation or Ink annotation or annotating anywhere in a document or dealing with rich structured information, you know, sales type information that you want to analyze. The fact that you have it in that form factor makes it all the more important that we get this kind of richness.

I think you'll be amazed at the maturity we've gotten that's in the hardware, the battery life, the breakthroughs in the wireless, and the software. We've been working all these years on handwriting recognition, hoping that the hardware would get to the point that it made sense, and now that we're there, all of that work, collecting samples building rich modeling tools has really paid off in what we're able to ship with that.

One element of .NET that I think some people really get and see as important as others are still kind of wondering about are the building block services, this idea that over the Internet there's Web services that you can just count on to be there. Some of these are extremely horizontal and are really fundamental for the Internet to be used in a very broad way, things like Passport, the idea that when you go to different Web sites you don't have to have a different user name, a different password, you don't have to re-enter it; any information that you enter in when you decide to share it with a Web site you can just do that automatically without having to retype the information. That's pretty basic. If we don't have that, then a few Web sites will become the only places we go, because just the trouble to get customization, to authenticate to the other Web sites, it won't be worth it and we won't want to have to remember those passwords, change those passwords.

In fact, the more passwords you have, the more of a privacy or security hole that password becomes. If you can have the one password that works against all the Web sites, then requiring it to be changed, to make sure that it's obscure, we can do that and many Web sites will insist that you not just authenticate through password, that you use a smart card as well. And so that's built in to the Passport capability. So this is an enabling tool.

Another key enabling tool is taking the idea of alerts, notifications, and standardizing those, making sure that they come through a common mechanism so you can pick which ones you're interested in, but making it so that anybody can publish out into that framework. This is a very important thing.

Passport is up today. We've piggybacked, of course, some of the free services we've had on the Web. We've got 200 million accounts and every month more than 3.5 billion authentications there.

There's a rich roadmap for Passport that we'll discuss in the breakout as we get to the richer levels of authentication and things like site authentication as well as user authentication.

The alert capability, it's pretty clear that people want to be notified of things. They want to be in control of what those things are, and there's got to be a framework. If every application is trying to pop up onto your screen and grab your attention and the way that you log those things and prioritize those things is different, you really won't want this alert thing at all. It's got to be run through a common architecture, the XML approach that we're using with these .NET alerts.

.NET My Services is the idea of roaming your storage, your calendar, and every different software developer will have their own schema. They'll choose to control and host that schema in most cases and they'll simply use our authentication and our notification infrastructure, but they'll keep on their servers the actual schemas that relate to that user's preference related to their applications.

So we'll do it for some broad horizontal communications related things, some other people may do that as well, but most developers will have their own equivalent, their own thing that fits into a My Services type role.

You'll have to decide in your business model whether simply including that roaming state capability is something that you provide with the application or if perhaps it's an opportunity for some type of subscription with the user. This model where software is easy to update over the Internet and where you can help the user roam their state across many devices really is leading to a new generation business model for the software industry that's less oriented towards one time package sales and more oriented towards regular subscription where people belong to these things. And so I think the .NET approach and the updating capabilities we've shown here will drive the health of the software industry along with their acceptance.

On your six CDs we've also go the Software Development Kit from My Services and alerts, including the ability to simulate those so that you can run within your own environment the ability to set up those schemas and try those things out.

We do think of this as a key element of the user experience, users being told what's going on and having their state available for all their different applications across all those different devices.

A great example of this is some pioneering work going on at Verizon, and so two of the guys who have been involved in creating kind of a breakthrough example of what .NET alerts can do are Kevin and Mahesh from Verizon, and let me ask them to come out and show you how .NET alerts and Verizon come together. Welcome.

KEVIN: Thank you.

(Applause.)

KEVIN: Hello. I'm Kevin and this is Mahesh.

MAHESH: Hi.

KEVIN: At Verizon Communications, the charter of the business group is to use the leading edge Internet technology to expand our current network infrastructure out to the Internet and PC desktops.

What you're looking at here today is the next version of the Messenger application with tabs running on Windows XP. The same way that you would initiate a chat session with one of your buddies, you can click on the Verizon tab and now manage your communication.

The two key things today we're going to demonstrate are how I can extend the reach of my current service that I have in Dallas, Texas and how I can also manage a lot of the services I have on that line without being tied to my keypad here.

For instance, Mahesh is going to make a phone call right now to my home in Dallas, Texas, and I'm going to manage it right from the PC desktop here in LA; and secondly how I can use this rich graphical interface to set some of my preferences with my call forwarding, and also to check my voice mail services.

As you can see right now, here is the result of the call that Mahesh just made to my home in Dallas, Texas. The first .NET alert shows the caller's name and number the same way that you would see it on the caller ID box, and the second .NET alert is showing that a voice mail message has also been left.

Rather than just being tied to these different devices in my home, I can access and manage my communications from anywhere I can get access to a PC desktop. By using a lot of the XML and SOAP technologies we're able to quickly build interfaces into different field and voice message platform combinations.

As we drill down on that caller ID information, I can see a comprehensive log of who's called me today and any voice mail messages, where typically I would have to use two different devices to access this information, my caller ID box to toggle through to see who's called, and secondly I usually have to dial into my voice mail server and find our who's left a message for me.

But the real power of this platform is that now I can take this caller ID information and add them into my contact list. Once my caller is in my contact list, I can configure how I'd like that person to be able to contact me in terms of priorities and the device that I'd like to be contacted at.

The next piece here is I can set up the preferences that I'd like to be contacted at. By using our Web-based calendar, in the same manner that I would set up any of my regular meetings or tasks, I'm going to forward all my local phone numbers from my home in Dallas, Texas to my cellular phone here in LA.

Mahesh is picking my home phone number and routing all the calls to my cell phone. He's setting it from 8:00 this morning until 10:00. Once that time has elapsed, it will automatically be routed back to my home.

Typically on Tuesdays I forward all of my work calls back home because I know I'm telecommuting. Once Wednesday comes I'm sure that all my numbers are back to work again.

As we can here, this is the result of Mahesh current dialing my local phone number in Dallas, Texas and it locally routing the number back to my cell phone here in LA.

(Applause.)

Our underlying inspiration for this work is really we want to marry the two items of PC computing and communication. And as we showed you today, we've got three very powerful telecom features: voice mail, caller ID and call forwarding, but how we add a lot more value to the user's experience is by integrating it with the .NET platform.

Thank you.

(Applause.)

BILL GATES: Well, that's a very good example of .NET at work. You'll see many others over the months ahead -- financial notification, consumer information notification, the things you care about with you in control of exactly what comes up.

Well, this week we've got a lot of new software that we're talking about, the shipment, of course, of Windows XP, up on our Web site the XML Parser that's been expanded with the version 4 XML Core Services, our SQL XML support has been expanded with the version 2 of that running on top of the last release of SQL.

Everything else here is on the CD, the release candidates for Visual Studio and the .NET framework, and the technology previews: What we call the compact framework -- it's the same kind of idea but for the smaller devices -- the smart device extensions, where we can exchange XML across the network, the Tablet PC we talked about, the My Services and alerts we've talked about. Office XP, we've got some extensions that let it get at all of the Web services. Commerce Server, likewise an easy setup for XML type servers. And a major advance in our .NET speech work, the ability to take and build speech into your Web server and even support not just pure voice interaction but also devices where you have both the voice and the screen. We think that that's the way forward for voice is that you'll have typically either a small screen as you interact with the voice or you'll have the large PC screen. And you want applications that can take advantage of that multi-modal type approach, and so you'll see that vision, the first company really pursuing that vision built into that speech of SDK.

We're also kicking off here a contest to gather up the best .NET applications. This will run until next June. It's already gotten started. In fact, I was over in Asia last week and we have an element of this focused on students. And I have to say I was really stunned to see the quality of .NET work being done there. You know, typically we think of developer trends as starting in the United States and taking quite a few years to spread outside. What we're seeing in this case is pretty much simultaneous global adoption of this move towards XML. As people have see that those Web sites that they threw together very quickly, they didn't have the right methodologies or architecture, they're now seeing that not only can they get those Web sites to be dramatically less code, more reliable, but they can embrace this XML approach at the same time. And so we're really seeing it particularly in Asia the level of interest I'd say is as high as anywhere in the world.

This contest it will be at Tech Ed next June where we'll have all the different awards. Up on our Web site we have the different categories, and just to let people see how quickly this is coming together and recognize some of the pioneers.

We do have a very interesting .NET application that was built at Microsoft that actually was used to shake out the Visual Studio environment. So let me ask Susan Warren to come on up and show us Terrarium and how can people here participate in using this application.

SUSAN WARREN: Thanks, Bill.

Hi, everybody.

(Applause.)

SUSAN WARREN: Well, as many of you know, I am a program manager on the .NET framework team, and we have been cranking like crazy to bring you a great new platform. You've seen some of that this morning. Now we're going to show you what we do to have fun.

So this is Terrarium. Terrarium is actually a simulated ecosystem where only the strong and clever survive. Obviously it's a game, but it's a game where developers use their programming skills and strategy skills to create animals and then they introduce them into the ecosystem to compete for a niche. We like to think of it as .NET meets Darwin.

So if you take a look at the one I've got running here, you can see I've got a couple plants, some herbivores, some carnivores. If you watch closely, you might see a little action, and that's interesting, but it gets better because Terrarium is a peer-to-peer network game, so when I introduce an animal here, it can actually spread across to other Terrarium clients and we get to see really interesting things happen.

So, for example, I brought a graph from an ecosystem that's been running at Microsoft for a little while and we start to see things that look like actual evolutionary biology trends. In this particular graph the life population cycle of the carnivores follows that of its prey, the herbivores, so pretty cool stuff.

But let's show you some code and see how you guys can write an animal for Terrarium.

Let's go ahead and get rid of that one. Let's bring up VisualStudio.net. So this is VisualStudio.net and this is the source code in C# for an animal I call Rocko. Now, Rocko is a big, fast eating machine animal. That's what he does. Think of him as a land shark. And I gave Rocko his charming personality by following one of the rules for writing a .NET Terrarium animal. You get a hundred points that you can distribute among the characteristics of the animal, so things like how fast can it run and how fast does it eat, how far can it see. For Rocko I made him a carnivore. I gave him good eyesight and really great speed. And the magic of .NET, he just arrived from a base class called animals.

I can also handle the little events inside of Rocko's life like being born or what he should do when he's idle, and I have some code here, for example, that says what Rocko should do when he's hungry. So here's the Find Closest Animal message. That's how he goes and finds his next meal. So that's Rocko.

Now, Bill, we went ahead and cooked up an animal for you, too. This one's in VB. (Laughter.) It's okay. VB is great, man. And this one is called Xboxie. Now, Xboxie is an herbivore, but it has a really great strategy. It knows and is always on the lookout for carnivores like Rocko, and it's got great evasion strategies to get away from carnivores.

What do you say we throw them together and see how they work together?

BILL GATES: Okay.

SUSAN WARREN: Let's start up an ecosystem over on Bill's machine, and let me go ahead and fire one up here and we'll introduce Rocko.

As I said before, this is a peer-to-peer game. Once I've introduced a few of these guys here, you'll see that we have the ability to teleport animals from one part of the whole ecosystem running on my machine to another part; in this case, Bill's machine. That's what this little blue ball is going to do. It's going to run over one of my Rocko's and send him over there. It works because the .NET framework's evidence based security architecture allows my Rocko to run in a secure manner on all of the Terrariums' peers.

So that's pretty cool stuff. We should get a couple before long. We're also using XML Web services to provide the infrastructure for the game, things like finding other peers, reporting and also even auto downloads of new versions.

So let's have a look here. It looks like we've got a couple of Rockos. Let's see if we can find some that are actually -- oh, yeah. Uh-oh, it looks like we've ganged up on one of your Xboxies. But the Xboxies are usually pretty good at getting away. Let's go up a little further to this corner and see if we can see a little chasing or something. Oh, watch out. It's getting away. It's getting away. Ah! I think it's doing a break dance or something.

Anyway, we gave it a little bit of sector space in there so they could run around a lot. It gives you an idea of what's going on with the game.

So, anybody here want to play this game? A couple of people? Want to write some animals? (Cheers, applause.) I thought you might.

What we've done is we've gone ahead and installed Terrarium on all 600 machines in the hands-on lab. Okay? So you all get an opportunity to do it. We've also made it available for download from GotDotNet.com.

And to make it just a little more interesting, we're going to have a contest this week. All of the animals that are written and submitted at the hands-on lab we'll put in a competition. The author of the best carnivore and the best herbivore wins a t-shirt signed by my buddy Bill here for Terrarium.

And even to make it a lot more interesting, we know not everybody here has time to make great animals -- you can to attend sessions, I think, most of you -- we're going to put everybody who puts at least one animal into the ecosystem in a hat and draw for an Xbox gaming system. So the winner will be announced Friday morning at Rick Rashid's general session.

So have a great time at the PDC. We think there's lots of good chewy technical content this time for you guys to soak in, and when you're ready for a break, stop by the hands-on lab and have some fun with .NET.

Thanks.

(Applause.)

BILL GATES: Well, peer-to-peer at its finest. (Laughter.)

Let me quickly wrap up with a little bit of a roadmap here. This year, of course, Windows XP, Pocket PC, the services coming out, the first few services in the existing Visual Studio.

Next year Tablet PC, a new round of servers in the first half of the year, a broadening of the My Services and, of course, the official packages of VisualStudio .NET will be out there early next year.

2003 is the next major milestone for us in terms of the Windows release. That will be a very important release, a lot going on in the peer-to-peer, a lot going on in the advanced presentation environment there. We'll have a round of servers that are timed with that, and of course we'll be able to go with the major new version of the tools that match up with that and a major new version of the services.

It's a pretty quick evolution. Part of this reflects the fact that because we've been very conservative in our financial approaches we're able to keep our R&D budget growing at this time, and so we're moving full speed ahead, lots of neat new things that are going on.

So I'd say that there's a real opportunity here. The XML type applications will replace the old applications. They will find new areas where computers weren't used before. The software business I think it's more and more recognized is really where the action is. Taking all those hardware breakthroughs and building them into real solutions, that's what the software people get to do. And so software is going to define this digital decade.

.NET should enable all of this, the agility of development, the way that the components can fit together, the fact that it's not rip and replace, the fact that it's totally flexible in terms of what languages you're using here, and so just like every new wave of programming development, our goal is pretty simple. We need to make literally tens of thousands of developers successful using this paradigm. That's how our platform will thrive. You know, the basic approach, the high volume low price approach, heavy R&D, long-term investment that we've used to drive broad computing to the level it is today, that's what will drive us forward.

So we're very pleased to see you all here and we're looking forward to seeing the applications you'll build around .NET.

Thank you.

(Applause.)

END