BILL GATES: Good morning. I'm very excited to be here at another sellout Tech Ed event. This is a very important event, because here we're going to talk about the breakthrough tools that will allow developers to write the next generation of applications.

I titled my talk today Developer Agility in the Digital Decade, and I think you'll see why we talk about developers being able to work far more efficiently than ever before.

The pace of technological change has not slowed down. Looking at what's gone on with the dot-com bubble, people often say, "Was there something real there; what was that all about?" And the fact is the promises of digital business, the promise of companies collaborating in new ways, all of those things are as important and as valid as they ever were. Some of the traditional views that the building of the technology would require the large companies that have taken long-term views, that's been reinforced. But the advances in the connectivity speeds, the advances in the chips that drive the different devices from the PCs to the new mobile phones to the new types of entertainment that we'll have in the home environment; all of these things are proceeding at full speed.

So we can expect power and connectivity as much as we desire. The only limiting factor in the whole picture is what kind of software is created, what kind of easy to use applications can be built.

And in order to facilitate this, there are a number of important emerging standards. Of course, this morning I'll be talking a lot about XML, because that is the centerpiece standard for how all these rich devices and these new applications will be pulled together.

I think people still underestimate in the decade ahead how much digital approaches will change the way they work and the way they live. The PC today has changed productivity, document creation. It's changed communications to a limited degree by adding in electronic mail. But things like how you record a meeting and go back and find out what was said or share it with other people, things like how you take notes, how you deal with photos and music, the way that business properties are coordinated, particularly when you have not just computers exchanging information but knowledge workers in different companies who want to work together. In every one of these areas we've barely scratched the surface.

And yet I can say with confidence in the decade that we're in right now, every one of those ambitious scenarios will become a reality. Some of the great advances involving the use of speech and handwriting will finally be solved and move into the mainstream.

And so it's this decade where we'll think of digital productivity in a whole new way. We'll think of digital communication, being able to have not just the phone as we talk with someone, but having our screens connected so we can edit documents and see information while we talk with each without any extra effort at all.

And, of course, the digital approaches will reach out into the living room as well in terms of how we find shows, communicate with friends while we entertain ourselves either passively or actively through the breakthrough devices that will be available there.

So we have a lot of software that needs to be written around all of these advances.

It was 10 years ago that here in Atlanta I had the privilege of introducing Visual Basic. So it's 10 years since Visual Basic came out. That's a great milestone because Visual Basic has been such an important tool in building new applications. And I would say that today is as important as that date ten years ago as we talk about Visual Basic and our other tools moving into this new era and driving these XML Web Service applications.

Now, most of you here have seen every decade the way that we think about computing and protocols, there's been a shift. In the 1970s it was about mainframes. You connected up with a purely dumb terminal and all of the code ran on the mainframe. In the 1980s the arrival of the PC got people thinking about empowerment, about the fact that you didn't have to wait for the expensive machine, that everybody could have the responsiveness of their own device. And so there was a shift to where the intelligence of the new code was mostly running on those PCs and the protocol was file sharing.

Then with the arrival of the Web in the 1990s we essentially shifted back. HTML, in many ways, is like the 3270 protocol; somewhat richer and with the ability to connect to any computer in the world rather than just the local mainframe.

And people talked about the fact that reading screens of information was what it was all about. And those applications were crafted very rapidly because of the business demand, because everybody wanted to be there with a business Web site very rapidly. And the tools really weren't ready for those applications, but people took what they had and they built the Web sites and that whole decade was really focused on HTML Web sites.

Now, in the last year, some people have talked about the pendulum swinging back the other way and the entire industry moving to peer-to-peer protocols. In fact, this time we don't think the pendulum will swing the other way. We think for the first time we'll have a balance where we can have the intelligence at the center and the intelligence in the devices themselves with the responsiveness they create and the rich user interface capabilities, things like the speech and handwriting; we can have the best of both worlds.

And so for the first time we need a protocol that allows intelligence to be in both ends. None of these previous protocols allowed for that. Each of them assumed that one end was essentially dumb and that the other end was where all the code ran. But with the arrival of XML, starting with a secure standard process, in which the Microsoft people were involved going back to 1996, now XML has emerged as the protocol for this era.

People talk about Web Services, the idea of connecting to any computer on the Internet and having it do work for you. Well, that will be done through these XML-based protocols.

And so this approach allows for applications that wouldn't have been possible ever before. It's these basic approach that will be used for electronic commerce, and it demands an advance in the tools.

Well, every one of these eras had key tools that were used for the applications. With the PC there was a version of Basic, Microsoft Basic. That's the last Microsoft product that I can say I wrote most of the code that was in that product. (Applause.) Thank you. It's a very obsolete product at this point. (Laughter.) Then the next stage was the graphical era for PCs and that's where Visual Basic really rose to incredible success.

I still remember meeting with the team and saying that their plan to ship the product without the extensible controls wasn't the right plan and that we needed to get third party control as part of that product, and that was one of the reasons that it was so incredibly successful.

Visual Studio is now our centerpiece development product, adopted to the HTML and other Internet activities that have been going on. And as we'll describe today, VisualStudio .NET and all the things around it are the breakthrough tools for this XML era.

Well, Visual Basic has had incredible success. It is the most popular development language and tool of all time. We're at over 8 million developers building business applications, and today we can say with great confidence that any application, no matter how small or how large, this tool scales to meet the needs of building those applications.

I thought for fun we could look at how Visual Basic has evolved over the years. There have been a lot of changes from the basic of the original IBM PC to VisualBasic .NET. And to help me show you how dramatic that change has been, let me ask Ari Bixhorn to come out and show us how applications look different. Morning, Ari.

(Applause.)

ARI BIXHORN: Hi. Bill.

Well, I am thrilled to be here today, because this week we are celebrating the ten-year birthday of the world's most powerful, productive and popular developer tool. And of course I'm talking about Visual Basic.

Now, to help set the context for just how far Visual Basic has come and really how far the Basic language has come, I'd like to take a step back just a few years and look at an application that was written in Basic. This application, called Donkey.bas was actually written by none other than the gentleman standing to the left of me. Bill, how long ago was it that you wrote Donkey.bas?

BILL GATES: Actually, it was myself and Neil Thompson at four in the morning with this prototype IBM PC sitting in this small room. IBM insisted that we had to have a lock on the door and we only had this closet that had a lock on it, so we had to do all our development in there and it was always over 100 degrees, but we wrote late at night a little application to show what the Basic built into the IBM PC could do. And so that was Donkey.bas. It was at the time very thrilling. So go ahead and show them what that looks like.

ARI BIXHORN: Let's go ahead and take a look at Donkey.bas. This is back in the day where the Basic language still had line numbers. We still had great constructs like "gotos" and I think that the development environment speaks for itself.

But to really see how cutting edge Donkey.bas was, let's go ahead and run it. (Laughter.) And as we can see, the goal of Donkey.bas is quite simply -- or not so simply to avoid the Donkeys. (Laughter.) Okay, well as we can see Donkey.bas is a minute to learn and a lifetime to master. (Laughter, applause.)

Now let's fast forward to the present day. Just as Basic had its sweet spots on the DOS-based PC, Visual Basic has had its sweet spots in Windows-based development and for the past ten years VB developers have been the most productive Windows developers in the world.

But we crave more. We crave more productivity so that we can crank out our applications faster than we ever could before. We crave more power so that we can build a much broader range of applications with maximum performance and high scalability. And of course we can't forget about the Internet. VB developers require the ability to build broad-reach Internet applications as well as next generation XML Web Services. Well, with VB .NET you get all that and a lot more.

And to help illustrate some of the great new capabilities that are available to VB developers in VisualBasic .NET, we've actually taken Bill's donkey game. We've scrubbed the code a little bit and we've updated it to run in VisualBasic .NET. That's what we see here.

Now, in addition to giving you the ability to write broad reach Internet apps and XML Web Services, VisualBasic .NET supercharges the Windows development experience. The first thing that you'll notice is a shaped Windows form. No longer do we have to be constrained to the old boring rectangular window. With VisualBasic .NET we can define a window in any shape that we desire. And in this case we've designed that window in the shape of a dashboard and a windshield.

Another great new feature in VB .NET is control anchoring and docking. No longer do we have to worry about writing that complex resize code that usually only worked about half the time anyway. With VB .NET I simply select a group of controls, I set their anchoring properties and now when I resize the form, those controls come with it.

Now, we could literally go on for hours about the new features in VB .NET. These are just two of many that you get as part of VisualBasic .NET. But to really see how far VB has come, let's go ahead and run the dot-net-ified version of Bill's donkey game called Donkey .NET.

Actually, Bill, before I run the game, we've got our Force Feedback Sidewinder steering wheel set up. Do you all want to see Bill drive? (Applause.) All right. Let's go ahead and run Donkey .NET. Bill, one thing to point out, the goal of Donkey .NET is actually not to avoid the donkeys; the goal of Donkey .NET is to plow over as many as you possibly can. (Laughter.) We've got our pedals down here. Take it away.

(Video game demonstration.) (Laughter.)

Bill, actually, if I could interrupt you for just a second, one other feature of Donkey .NET and actually in VisualBasic .NET that I'd like to point out, you're hearing a lot this week about XML Web Services and how XML Web Services allow you to aggregate the islands of information on the Internet. Well, just as VB developers have always been able to call out to other components and use them in our applications, we can now use Web Services in our applications and we've actually incorporated them into Donkey .NET.

If I simply click on the Donkey .NET XML Web Services tab, and I'm going to spin around so that we can see the donkeys once again, what we've actually done here is called out to a Web Service that queries the Internet and it finds other models that we can swap in place of the donkeys. Bill, what do you say? What is our next target: evil bunny rabbit or Blackbeard the peg-leg pirate?

BILL GATES: Oh, let's go for the pirate.

ARI BIXHORN: We will go with the pirate. And, folks, just so you know, no pirates were actually hurt in the making of this game. We can simply revive them. (Screams from videogame.) (Laughter.) Let's go up over the hill here. There they are. (Laughter.) (Screams from videogame.) (Laughter.) Thank you, Bill. How about a round of applause for the driver? (Applause.) Thanks, Bill.

And what we're looking at here is beta 2 of VisualBasic .NET and in beta 2 we've improved compatibility with previous versions of VB. We actually spoke to one of our customers who's been building VB 6 applications and using the VB .NET upgrade tool in beta 2, they were successful in bringing 99 percent of their VB 6 code forward to VisualBasic .NET.

In addition, we've extended the VB language in VB .NET to include new powerful constructs such as structured exception handling, which we see here, implementation inheritance, free threading. And while all of these constructs are completely optional, they give you that added headroom that we sometimes need when we're building applications with unmatched power.

Something else to call out here is you'll notice that we're making calls into a graphics engine. This graphics engine, called Revolution 3D, was written entirely in Visual Basic. This is just another example of things that were never before possible.

Finally, too often when we're writing our code, we'll write our code from scratch rather than reusing existing code. Well, with the new code swap add-in for VisualStudio .NET, VB developers can use Web Services to query out to the Internet an find code snippets that have been published by other online developers. I simply type in my search criteria. In this case, we're looking for a sorting algorithm. And when I hit search, that Web Service is called and a list of results is returned. We can simply double click on any one of these results and have instant access to it within the VB .NET integrated development environment. This is just one other way that VisualBasic .NET maximizes your productivity.

Now, we've seen a lot today. We've seen how VB is ready for a new era in application development. And, in fact, to help you get started with VisualBasic .NET programming, we're going to take all of the source code from Donkey .NET, as well as the binaries from Revolution 3D's graphics engine and make them available for download on MSDN. (Applause.)

Everything that we saw here today, does it imply that VB .NET is all about creating games? No. What it means is that VisualBasic .NET gives you the power and productivity to build any kind of application, be it a rich Windows application as we saw here, a broad-reach Internet app or a next generation XML Web Service.

The last 10 years of VB have been great, but you know what, we are just getting started. XML Web Services, free threading, implementation inheritance, structured exception handling, shaped windows forms are all just the beginning of the next 10 years of Visual Basic that will blow you away. And with VB .NET your programming possibilities are limitless now and into the future.

Thank you.

(Applause.)

BILL GATES: So VB has come a long way.

One of the other elements that's helped drive our industry forward is the idea of broadly accepted standards: the PC hardware itself, which was crafted in a way that many companies could build the hardware in introducing this idea of full compatibility. We're seeing the power of that come to the server level now. Yesterday you heard from Paul Flessner the incredible benchmarks taking place on industry standard PC servers and the breakthrough idea of scaling those systems out by adding new modules, new system boards, whatever you want, to get essentially arbitrary performance.

Windows itself was a broad standard, learning the interface, learning the programming model.

The HTML standard, which was done through the W3C process, was also very important.

The centerpiece for this new era, XML, of course, is a very broad standard, something that will run on every single computer system.

Now, there have been a lot of milestones in pulling XML together. This is the history of various submissions that Microsoft has made going back about five years. This is the history of the recommendations that came out of that work. And here we have the history of the product that Microsoft has created that are for XML development.

XML is the centerpiece standard. You all have heard the many things that are going on around XML: SOAP, WSCL, UDDI; all of those standards together create this new Web Services computing model. In fact, we're working with industry partners to package up all those standards in a way that people can test platforms and applications to make sure that they're fully XML compliant.

Why is that important? It's important because as long as your company is building applications that way, you get a level of interoperability between them that was never possible before. And you have the choice of for each application taking the best platform. Now, Microsoft for this product will compete to be the platform for those different applications, but no matter how you're using them, the XML approach will make sure that your data can be exchanged.

So much of the glue code that IT departments have to write or that consultants were brought in to develop will no longer be necessary as long as companies are careful about schematizing their data and sharing those schemas. Many of the schemas will be industry wide, but some of them will be, in fact, company specific, and getting that right will be a key effort of the IT architects.

Now, as Microsoft moves forward in this XML era, we're going to be building a lot of rich products, a lot of XML protocol driven products. One of the initiatives that we call HailStorm is about taking information and making it available to any device, so that things like your schedule, things like your e-mail, your favorites, all of those things can show up automatically on any device. As long as you've authenticated who you are, that information shows up.

Now, HailStorm is very, very broad. Think of things like health records, bank records, music preferences or more business oriented things like the business intelligence profile you have where you like to be notified if certain things change inside your business. All of those things should be available everywhere, but there's a lot of domain expertise in each one of those things.

So Microsoft has created what we call the Shared Development Process where we can interact with customers and other companies in the industry to make sure we get the definitions of all of these things right and get them into products that we get out into the market very rapidly. And so this Shared Development Process is something that we've put a lot of effort into to make sure we can draw on everybody's work, and the framework for how we're going to take that and turn it into products is very clear. So up on the Microsoft Web site we have now this description of the various events and things we'll do around this. It really combines the best of both worlds, the ability of Microsoft to create the products, but the ability of the entire industry to make sure that it's fitting the needs that are there.

So in this world of new applications, the tool is of vital importance. And XML Web Services demand a very rich tool.

I would also say that even the previous eras of building HTML Web sites, the tools were not quite adequate to the job, the complexity of those applications, the different pieces that had to be tracked, the performance codes that had to be written, the monitoring code that had to be written. In a sense, the tools never 100 percent caught up, even with the HTML Web site applications.

So with VisualBasic .NET we're really doing two things. We're providing the fantastic tools for those applications and we're making it easy to take those applications and write them in such a way that they are XML Web Services.

Any Web site that's out there today that was written before this tool came along, the amount of code that's necessary to recreate that and to make it far easier to maintain and make it far richer is a dramatic change as we move up to VisualStudio .NET.

So it's about developer agility, agility meaning that ability not only to build new applications, but take the ones you have and modify them for your business needs.

It really fits the whole business theme that exists and what most people refer to as the post dot-com era, an era where getting projects done quickly and with reasonable budgets is of renewed importance.

And certainly in this environment we need to tap into the PC. We need to make it so that you're not just clicking through pages, but you can deliver information down to the rich applications that run on the PC. Whether that PC is on online or offline, the knowledge worker who uses that ought to be able to view data that comes from many different Web sites. They ought to be able to annotate that data and edit that data and have it go back up and be shared through very rich Web sites.

The data ought to be able to be projected out onto different devices. No one can predict what different screen sizes or form factors will actually be popular. No doubt the full size screen device, the PC device will be the most important device, but as people travel around, the smaller devices will be very important as well. And so you need to write applications in a way that you're not tied to what developments might take place there, whether those devices might have speech interaction, whether they might have different form factors and different buttons on them. And so the tool has to be rich enough so that binding to each one of those things is very, very simple.

Now, for people who want to build Web Service applications, we've had our SOAP toolkit that works with all the Visual Studio capabilities in version 6. It's only with .NET thought that we actually take this idea of a Web method and in the language itself allow you to declare procedures as being connected up through XML and the Internet.

The .NET framework is a key part of this. It's the runtime environment that is designed around XML. ASP .NET are a set of capabilities that are part of the .NET framework that run up on the server. And to illustrate the power of the framework, we took a very classic Web applications called Nile e-commerce application and we were able to write it with 70 percent less code and because of the rich runtime we were able to get over three times the performance.

A key point about our approach here is that you can take existing code into this world and that you can take any language that you want. Languages are going to continue to have a lot of variety. There is not going to be one single language. Whether it's Visual Basic or Java or C, no one language is going to dominate. In fact, the variety we expect will actually increase in the years ahead. As each of these languages innovates around XML, they will all be quite vibrant and it's very likely that several new languages will emerge. That's one of the reasons we've worked so closely with the academic environment to build their breakthrough languages on the VisualStudio .NET environment, so that as those emerge, whether it's for an entire application or just a piece of an application, it will fit into the environment.

The kinds of breakthroughs I expect there have to do with declarative programming and making the effort to match your data formats to how you program against those formats and make that very simple.

This week we've added Fortran and RPG as two supported languages, where commercial developers have come along and created compilers for those that fit inside the single VisualStudio .NET shell environment.

We're very excited that VisualStudio .NET, this new version is on the verge of release. A key thing that we're announcing here today is that we've achieved our beta 2 milestone and, in fact, all of you tomorrow will be receiving the CD for beta 2. (Applause.)

Beta 2 is probably the most solid beta that we've ever seen. It's a very significant step in the release process. We are confident that that release will take place this calendar year. (Applause.) That is I think a very key commitment from Microsoft.

We ourselves have been using VisualStudio .NET to build a lot of applications. And that experience has been invaluable. The positive feedback from our internal developers on this thing has exceeded any tool that we've ever worked on, and, in fact, the internal developers and a lot of external developers have been very anxious to say, "Hey, these applications work great. The runtime is totally solid. We'd like to go out and ship those applications." And so we're going to give people a way to do that.

First, before we get into that though, let's actually take a look at what it means to write one of these Web Services. And I'd like to ask Ty Carlson, one of our developer evangelists to come out and show us this in practice.

(Applause.)

TY CARLSON: Good to see you. What I want to do today is show you the power of integrating multiple Web Services in a VisualStudio .NET application. What we want to do is integrate four different XML-based Web Services in this application. The first XML service is the Scandinavian Airlines get flight status call. This is a production Web Service built on beta 2 of VisualStudio .NET that has just gone line.

The second Web Service I want to add in is Traffic Station. Traffic Station provides XML real time data for traffic information for over 30 cities around the U.S.

The third Web Service we'll be adding in is HailStorm Notification. HailStorm Notification allows us to provide real time messaging and real time notification to any device. In this case, we'll be using Windows Messenger Service.

And the fourth Web Service we're going to be adding in will be a new prototype application for Microsoft's Map Point that is Web Service enabled. We call it MapPoint .NET.

So what we have here is an application -- and I know, Bill, you're a traveler, so let's set up the scenario for what you're doing today. You're in customer meetings with customers in Forest Hills, New York and this afternoon or this evening you head out to Copenhagen via New York. So what we need to do is make sure that you get to your flight, your SAS flight from New York to Copenhagen in time.

Okay, so let me go ahead and enter the data for you. So we go ahead and select Forest Hills, New York and, of course, the destination now of Newark International and then we enter the destination and the time that you need to be at the airport, which is 6:16 PM sharp.

And what we're doing to use is we're going to use the abilities of MapPoint .NET to go out and calculate the best route to get from Forest Hills, New York to Newark International airport and it will go out and select the best three routes and break them into segments. That segment information is provided to the Traffic Station Web Service that provides real time traffic information for those various segments, which allows us to calculate the best time and the best route to be able to get you to the airport on time.

So right now you're supposed to depart in 5 hours and 58 minutes from your meeting in Forest Hills, New York to be able to get to Newark International Airport on time and make your flight.

So that shows you one of the neat things about this is its ability to take multiple Web Services and integrate them together and to create new applications using VisualStudio .NET.

Well, let's show you some more. Let's go ahead and show how easy it was for Scandinavian Airlines to go out and create that Web Service.

So let's go ahead and show you a bit of sample code and how easy it is to create the Web Service is you simply go ahead and add in a call to Web Method. It's just a simple tag that you add on. And by adding Web Method in, okay, and of course saving it, and we'll go ahead and run that, we have now created -- it's important to do it in the right location. So let's go ahead and put it in the appropriate location. I had the Web Method just below the call. I should move it above the call. That's supposed to be the drag and drop part of the demo here. (Laughter.) So we'll go ahead and add it into the call and now we've saved it and we'll rebuild it.

And now what the Web Service provides is we have an auto-generated description page of the XML call. This allows us to go out and test the call that we've made, get a flight status and enter the flight number -- and I believe you're on flight 912 today -- and then the day, which is zero, because we're flying today. And I'll go ahead and invoke that. And that provides us back with an XML dataset to be able to use and consume that information by VisualStudio .NET applications. So it's very, very easy to be able to create Web Services using VisualStudio .NET.

So with that, let's show how easy it is then to be able to consume this service from an application.

Now, so we're going to go back to our travel application and what we want to do is we want to be able to go back to the code, so we're simply switching to code mode, so just right click and view code, and now what I have is a nice to do entry point, and, in fact, I can go to my task list and show it, and this section tells me where to add in the Web Service call, and it goes here.

So let's see how easy it is to be able to use VisualStudio .NET to be able to add in a Web Service. Now, for those of you who have been writing COM and VB 6 applications, this should be very familiar to you. This is a very easy step forward. So we simply go in to Web references and we add a Web reference.

Now, we have the Add Web Reference dialogue box, which allows us to add a Web reference from the local machine or anywhere on the Internet, or to go out to the centralized registry out on the Internet called UDDI to be able to go get that information.

Now, what we'll see is that we enter a business name and we're going to look for the Scandinavian Airlines Web Service and we'll go ahead and search for that and there we see the SAS real time flight status. So I click on that and here's the flight status Web Service itself and we click on that and here's the XML return from the Web Service and the contract information for adding that into our project. So we simply click on Add Reference and now we can see that we've added into our project the Scandinavian.net Web Service. So this is a very easy way to be able to add that into the application.

Let's just add it in programmatically, so we'll go ahead and deem WS Flight as new. Now we're going to notice this as netdoc and we'll see the Intellisense, which makes it very easy when you're typing on stage in a demo or programming late at night, as the case may be, to be able to add in this Web Service. So we'll go ahead and my result equals, then we notice Intellisense here as well as we get here WS Flight-doc and we want to be able to get flight status, so we'll simply enter that in.

And then we have Intellisense again because the Web Service returned its parameters, which parameters we're supposed to use, so we enter in the flight offset or the flight number and then the day offset and now we've added in the Web Service.

So let's go ahead and then save that and control-F5 and we'll go ahead and run that. And now what we'll see that we've created is a very powerful new application that allows us to take advantage of even more functionality.

So one of the things that we can do, for example, is go ahead and take advantage of yet a fourth Web Service and that being HailStorm notification.

Now, I know you're going to be in meetings, Bill, so what I don't probably want to do is interrupt you with a telephone or maybe e-mail. Why don't we go ahead and use Windows Messenger to provide you with that information. And I know you travel a lot, so let's cut that time down to 60 minutes. I know you're a very efficient traveler. So let's go ahead and so that. Let's go back to the planner and now that we've added in both the get flight status Web Service and the HailStorm notification, we simply enter in our start point and then the SAS flight number. And the SAS flight number will then provide us with the information of which airport we're departing from and then we'll be able to go out and calculate what time we need to leave for the airport, based upon the real time information of the traffic conditions, as well as the current information on the flight status coming in from SAS.

So now if we go out and provide that information we can maximize the time that you're spending with customers and at the same time getting you to the airport on time.

So as you see this as it goes through its calculations, it's notifying heavy traffic conditions and identifying which is the best route and what time we actually need to leave for the airport.

So 6 hours and 38 minutes. It recognizes the flight is leaving from Newark at 6:15. So the get flight status call gave us the information about the flight departure time. So we'll notice that also MargiesTravel.net is using MapPoint's direction and giving us that information.

So let's go ahead and advance this to be able to see what happens when we actually start approaching the time we need to leave for the airport. So we'll simply fly forward in time here and our notification is under an hour. There's our notification that we need to leave for Newark Airport. That's coming in via Windows Messenger service from HailStorm. We click on that and it takes us to the logical place that we want to be going is the travel guide on the Scandinavian.net Web site to be able to provide us with the flight information and the travel information that we have.

So what XML Web Services allow us to do is to create powerful new applications that we can easily integrate into our existing applications and allows us to be able to extend the functionality of our applications in a very easy way using VisualStudio .NET and the toolsets that are provided with that.

This allows us then to be able to have a very fun time using the XML Web Services that are available today that you can simply take advantage of as you take advantage of beta 2.

BILL GATES: Thanks, Ty.

TY CARLSON: Thank you, Bill.

(Applause.)

BILL GATES: So a number of announcements around this: The first is what we call ASP .NET Go Live license. This is letting people take the existing runtime and go ahead and deploy Web sites. And we've got a lot of people who are doing that.

Another announcement is the availability of the Mobile Information Server. You saw a little bit of that product yesterday. That extends all these things we've talked about onto how people want to manage their mobile devices.

And finally up on MSDN you'll find some new developer technologies, including directory capability, UDDI, making it easy to get at that, this Mobile Internet Toolkit that lets you write to any of the different cell phones very easily, and sample code for peer-to-peer. The .NET approach fully supports peer-to-peer and so we thought we'd put some samples up there to show how very rich peer-to-peer applications can be written with very few lines of code.

This ASP .NET Go Live capability really is something that was demanded by people working with the data. Here I have a list of Web sites that are either live today or will go live very soon using VisualStudio .NET. As I mentioned, you'll see a lot of Microsoft sites there. The word of mouth has really driven this to many, many groups at Microsoft. It's quite different than happens sometimes. Sometimes with other things, I have to go to the different groups and say, "Please use this new thing." In this case, people have been really pushing the other way, saying, "Hey, this makes us so much more effective," and we also see that with a lot of the external customers here as well.

Well, one of the customers that you saw listed there is SAS. And SAS not only wants to do some of the things for the PC we showed there; they want to reach out to all different devices. And so to talk about what SAS is doing with the business problem they're solving, we're very lucky today to have Mats Fagerlund here, who's the vice president of sales and distribution. So let's welcome Mats to the stage to show us what he's up to. Good morning.

(Applause.)

MATS FAGERLUND: Thank you, Bill.

Well, SAS is one of Europe's leading airlines and compared to most other airlines, we have very much business travelers. And we are committed to making their traveling as simple and as flexible as possible. And in order to do that, we have developed quite an advanced self-service concept, including mobile solutions. And we have built our platform on Microsoft technologies and we are now working with the VS .NET beta to expanding our offerings to new devices and to new XML Web Services.

So, Bill, I'd like to show you what we are building with .NET. And for the demo we have booked you on a flight from New York to Copenhagen, and one of the things our customers need is to check their flight status via cell phones. And we have enabled that by using your Mobile Internet Toolkit.

BILL GATES: That's great.

MATS FAGERLUND: Indeed.

TY CARLSON: So what SAS has done is they have today an existing Web site based upon COM+ and VB 6 and they've been able to use VisualStudio .NET to be able to extend that functionality to mobile devices. So let's take a look at how they've done that and to be able to use the exact same flight status that we used in our previous demonstration to be able to check the current status of the SAS flight.

Now, as you remember, the SAS flight was number 912, and what this allows us to do is to use the mobile devices to go out and check the flight status as well as do other types of operations.

So here we go and we've brought up the Scandinavian, which is mobile.scandinavian.net, conveniently, and we can do ahead and go to the status option, go ahead and enter in the flight number that we want to look at and the flight number is 912. We go ahead and click okay and now it wants to know which flight we were worried about -- today, tomorrow, what have you. Of course, that flight is today that we're looking at. And now it will go out to the data center back in Copenhagen and be able to get that information in real time off of that.

So flight 912 from Newark to Copenhagen is on time. So it's a very handy way to be able to see what your current flight status is as you're moving around.

Now, this is very handy because of the mobile device. You could be on your way to the airport, for example.

MATS FAGERLUND: Well, perhaps the application we are most excited about is the ability for our customers to rebook onto a more convenient flight as their plans change.

So, Bill, imagine that you have a meeting running over on the day of the trip to Copenhagen. Wouldn't it be nice to be able to use your cell phone to change to a later flight?

BILL GATES: If it's easy, you bet. (Laughter.)

TY CARLSON: Well, let's take a look. We're here with our -- now, this is a phone that's used in Europe a lot and we will simply go ahead and log into the mobile Web site using name and password, of course, Bill. Now, this is a real reservation on the Scandinavian Airlines network. We're able to go out and look at the booking that Bill has, specify the booking and it will go out and check the dataset for the flight legs and the flight information for that specific booking.

Now, we have you booked in this case out in November simply because SAS has a very heavy flight load and, of course, we'll be traveling later on.

So as we do that, we'll go out across the Internet, access the dataset and, of course, we'll return now with both the outbound flight and then the return flight. And so, of course, the schedule might run a little late on the return flight, so let's say 26th of November at 6:15. Let's go ahead and move that to a later flight. Let's change the booking. And now as we go to change the booking, we want to specify our route. This is a return trip. And then we want to specify the appropriate date and time that we want to change the booking to and get that information. So the travel date you want to return on is the same day, but let's move it back a little bit to maybe 11:00 or something like that we'll head back. And then we'll continue.

Now, it will go back into the dataset and provide us with what the available flights will be on that day that we can take and the appropriate connections we'll be making.

Now, the handy thing about being able to do this in a mobile device is the ability to actually do real type of work on these mobile devices. Flight status information is very handy, but the power to go out and truly rebook your flight is something that typically would be something you'd have to do over the phone using voice or standing in line. You could be doing it this way and customer service is dramatically improved because there you go, let's go ahead and confirm that change on your flight, and we'll go ahead and set the booking real time against the SAS system. So this is just a wonderful way to use mobile devices and to extend the application that SAS has implemented on the Scandinavian.net Web site using the VisualStudio .NET toolset to be able to go to a wide variety of mobile devices. And as you see, the booking has been made and we'll go ahead and log out.

Now, one of the things you'll notice is also the ability of VisualStudio .NET and the Mobile Internet Toolkit, how it extends the functionality of the application. One of the powerful things that we can do with this type of application is go ahead and use the mobile controls that are provided by the toolset to be able to implement these controls and use them in an adaptive way so that when you use mobile controls it understands the capabilities of the device and then changes its behavior accordingly.

So let's go ahead and add a mobile call control to our application. And we'll go ahead under the support page and just add a call control in, so we now have the call control selected, and we go in and change the text that we want to read, because obviously we want to make this personalized for SAS right, so we'll go ahead and add that. It's going to be "call SAS on" -- and we'll enter the phone number as well. So we've entered the phone number. We'll go ahead and save the project. And now as we save the project we'll go ahead and build it as well.

And now let's look at the project using the same phone we were using before and now let's go ahead to our site, development test site, connect into the service, and now as we go to the support area there, it says "call SAS on". This is the control, the mobile Web control I just added onto this page. So it says "call SAS on" and now because the device is a telephony device, it wants to change from a data call into a telephone call and it actually tells you we're going to hang up and make the phone call.

Now, if I show this device on a different type of device, let's take a look at what a different device would look like. Let's go ahead and switch now to a Pocket PC. And as we switch to the Pocket PC, we'll see that we have functionality that allows us to use the same control. Let's go ahead and refresh that so we have the real dataset. So we'll go out and connect in then and we'll go ahead and look at the same call control on a Pocket PC. And what we'll see here is that it says "call SAS on 1-800-221-2350". What that allows us to do is the controls automatically adapt when it's on a device that doesn't have telephony capabilities and will act accordingly to what the best capabilities of that device are.

So the neat thing about using the Mobile Internet Toolkit with VisualStudio .NET is it's very easy to take an existing application and extend it out to support a wide variety of devices with a minimal amount of work. The tools are very easy to use.

Now, of course, one thing about these types of devices though is that these devices are capable of even doing extended things. And one of the more interesting things that we've seen is the work SAS is doing on a prototype application to be able to extend the functionality of their rebooking application that we've just seen to including the functionality to actually do seat selection as well.

So let's go ahead and do SAS seating and now we have the actual seat map for that application. So this allows us to be able to take advantage of the functionality of the Pocket PC and extend it on these mobile devices and have a very rich user experience to do that.

So do you want maybe a window seat, Bill, to get a nice view of New York as we head out?

BILL GATES: Sure.

TY CARLSON: We'll go ahead and then change you over to seat 5H. Okay, so it says the current choice is 5H. And we'll go ahead and continue. And you'll see that it's been successfully changed to seat 5H.

So as we've seen, the Mobile Internet Toolkit allows us to quickly be able to extend our applications for mobile devices. The mobile controls provide adaptive behavior to adjust to the appropriate mobile device that you've implemented it on and allows us the power to be able to customize our applications for the capabilities of the different devices. And this just makes a very powerful development environment for us to work in.

(Applause.)

MATS FAGERLUND: Another advantage is we can easily integrate new features into our products using the drag and drop user interface in your tools.

TY CARLSON: Indeed. And by adding those controls onto those feature sets, it allows us to be able to quickly adapt to those new devices and it's a very handy way to be able to do this.

BILL GATES: Thanks. Great to see what you're doing with all that.

TY CARLSON: Thank you.

MATS FAGERLUND: Thank you, Bill.

(Applause.)

BILL GATES: Well, so SAS is a pioneer, but the direction they're going I'm certain is the direction that every business is going to go in terms of building state-of-the-art Web sites that use .NET to connect to all different devices.

Well, this year Microsoft has a lot of breakthrough products. This morning we've focused a lot on VisualStudio .NET. In the same timeframe we'll also be shipping a new version of Windows, Windows XP. Now, this will complete a year where we've had BizTalk ship, Office XP ship, so a lot of the XML focus is having a huge impact on these major new versions of our product.

Windows XP is a very significant release, because for the first time we're seeing that all Windows users from home users up to a 32-processor server should use the new Windows engine. We've had a bifurcation with Windows 2000 for some users and Windows 9X for others, but now we're taking and saying this is the mainstream code base, getting Windows into one extremely reliable engine, the so-called NT engine. We've refined the user interface. It will take someone only a minute or two to get used to it, so you'll find it's a substantial advance. We include a lot of rich things for new experiences, things like publishing information, dealing with photos, music, notifications. Things are a lot richer.

Real time communication is one of the big themes here. We have an instant messenger that's very appropriate for corporate environments as well as the consumer environment. And the instant messaging is not just text; it's also video and audio, but most importantly there are application interfaces so that your applications can connect up with these real time capabilities. So, for example, a customer service application would connect up and be able to do screen interactions with anybody who's connecting in.

So ..NET is built in to Windows XP. Down at the client level we have Passport, we have notifications, we've got XML and SOAP. Up at the server level in the equivalent server release, which comes after Windows XP, that will be at the end of October this year, so next year we'll have the server equivalent, which we call the Windows .NET Server. Previously, those had been referred to by the code name Whistler Server and so we're announcing the product names that those will go by.

These will be a big step forward in the .NET arena, because of the Passport to Active Directory integration, so that you don't have to re-authenticate yourself one way for the Internet and another way through your corporate network.

The servers ship with the world's richest application server, so the entire framework in ASP .NET are there. The idea that we don't force people to buy a separate application server, we have enhanced forms of that, but the base application server in the operating system is something that people have really missed when they've looked at our offering, because that simplicity of knowing that it's part of the platform is something that means you don't have to go buy something extra and you don't have to wonder which of your servers have those capabilities; every Windows server has that.

The rich programming functionality that we've built in, things like the queuing with MSN Queue, that's now using SOAP, so it's .NET focused. All of the COM+ capabilities are integrated in with .NET. And so that server release is a great evolution of the whole story here for rich development.

So to summarize, I think the opportunities for developers in this next decade will be phenomenal, not only taking the existing applications and doing them in a much better way with Web Services, but enabling new applications, business efficiency, business communications, notifications when you need them, dealing in rich media types, taking knowledge workers and their efficiency to a whole new level. So it's distributed computing, the dream of distributed computing delivered across the Internet. We've got industry standards that are central to it and we have commercial products, particularly VisualStudio .NET that will be driving this forward.

So all of you are at the beginning of something very important. You're all learning about the XML Web Services and how you can use those with our Microsoft .NET work to deliver the best solutions for your company.

So we're thrilled to have you here and we're thrilled to see what you do with these new tools we're creating.

Thank you.

(Applause.)