Remarks by Bill Gates
Visual Studio .NET Launch Event -- San Francisco
February 13, 2002

BILL GATES: Thank you. Thank you. Well, this is a very big day for us. With all the excitement taking place, the Olympics, the conference, the Visual Studio .NET introduction, I wanted to make sure there was one thing that no one here forgets, and that is that tomorrow is Valentine's Day. So, even if you're at the conference, keep that in mind. In fact, last night I was thinking, what am I going to do? And I came up with the perfect idea. It's a pretty exciting Valentine gift, I'm sure that will work for a lot of you as well.

Software development has been through a lot of changes over the last several decades, many big paradigm shifts have taken place that have driven the software industry to a new level. And it's fair to say, those software advances can play the central role in the advances in the economy, the productivity improvements over the last several decades have really been driven by software.

Microsoft has been in the picture with the arrival of the PC, and the idea that the software industry could be a very large industry. It's grown literally by thousands of times since the advent of the high volume, low price model that was made possible by having millions of PCs all running the same operating system.

In those early days, we learned about evangelism. We learned about the importance of tools, and those are lessons that we've never forgotten as we've moved into new generations. A very interesting transition was moving from character mode, MS-DOS to the graphical interface. That was a tough one because the hardware, at first, was a little slow, and it was fairly difficult to do the actual development. People had gotten used to the breakthrough MS-DOS rules, Microsoft Basic, Turbo Pascal, Quick Basic, and at first we didn't have equivalent tools for the graphics generation. But then, Visual Basic, Power Builder, Delphi, several breakthrough products stepped up and made it common sense that it was as easy to build graphical applications as character mode applications.

The last big change before the one taking place right now, of course, was the arrival of the Internet itself. And this really changed the paradigm to be an application on a server delivering HTML to a browser. You were connected to a single site at a time, and it was the user getting the information. There was not software on both sides. Really the key software other than the browser was all up on the server. A lot of tools grew up here very rapidly because there was this almost bad or phenomenon, one could say, where everybody had to build these Web site applications very quickly. And that was a very important change, but as people talked about the potential of the Internet, they realized this idea of only having the intelligence on one end was limiting, that the really key applications that people wanted to develop involved having intelligence on both ends, allowing the user to see information from many different Web sites, allowing them to edit and annotate that information.

In fact, a classic application that people thought about was e-commerce. How do you take a complex organization, say Company A, and connect it up with Company B? Inside Company A you have many different systems running. You have lots of different knowledge workers all engaged in the business relationship with the other company. And it's equally complex on the other side. So, how can software take this situation and make it more effective. Make it so that digital approaches give complete awareness of what's going on on both sides, and allow it to be dramatically better than the paper-based or phone-based approach that's used today.

And so, this required an architecture that's different than anything that existed in the commercial world before. The idea of distributed computing, where different systems can connect up to each other, had been in academia for a long, long time, but now, for the first time, it was necessary to build something that would meet this imperative.

Back in 1996, a good step had been taken, which is that the SGML structured document standard had been generalized by Microsoft and some other companies into an XML standard, and that standard was gaining momentum. But XML alone wasn't going to be enough to allow any computer on the Internet to connect up to any other computer, finding its capabilities, and sending information back and forth, even in the face of unreliable connections, in the face of the fact that the developers on both ends had never met each other and coordinated what they were doing before, and even in the face of the fact that these systems need to be robust in the face of even malicious code running on the other end. So, a big challenge, but one that the industry got focused on to pull the pieces together.

And the result is, of course, XML Web services. These services standards are open standards in the same way that HTML is being generated and displayed on systems of all types, the XML-based standards are there and there will be great competition in terms of who implements these standards in the best way. So, in the same way that in the world of graphics interface we had Macintosh, OS2, Windows and other systems, here we'll have many stacks that compete to work this way, but they will be interoperable with each other.

It's a new approach to programming. This is really message-based programming. And yet, we need to make this transition without going back to people and saying, there's only one language that's a good language, or saying to people that they need to rebuild their software. We need to show them a way to transition to this approach in an evolutionary way. In particular, we need to let them build a simple layer on their applications that does the XML services mapping, and use that to integrate these systems together in a rich way. We need to make it so it's literally only months of work for a very complex application to provide that type of interface at the top. Over time, of course, applications will be rebuilt around these concepts, and that will make the applications simpler, easier to modify, and far more effective.

One of the amazing surprises over the last several years to come out of this work on XML Web services is even though this is a necessary architecture for connecting two companies together, this architecture is incredibly powerful and beneficial even within a corporation, the way that different applications relate to each other, server to server, the way that knowledge worker information, say in a spreadsheet, relates to information running inside an application. It has profound implications for those things as well.

For Microsoft, this is the paradigm we'll use, even inside the system itself, the paradigm for how manageability will be done for all of these different software systems. So, over the last two or three years, we've seen industry support build. And I don't just mean the product suppliers in this industry, the pioneering developers have really been clamoring for this type of approach. As we've put out different white papers for posing advances here, we've had many customers take those white papers and run ahead and actually build applications based on those things, because the need for these approaches are very, very strong.

Now, with all this excitement taking place, there's been a concern, and that is that there would be incompatible approaches for these Web services. In fact, over the last couple of years, we've had a dialogue with IBM in particular where we've said, hey, both of our companies are committed to this, how can we see that these systems will interoperate. And it's not a simple challenge because there's very good ideas coming from many companies. For example, in the area of orchestration, IBM has had some good ideas, Microsoft has had some good ideas. Many of the elements of how you map from a procedure calls index in XML, and people had different approaches that they came up with to meet that need.

But how can we put aside those differences, come to agree on a common set of specifications, put together a profile that says which of these specifications are necessary, and guarantee our customers that we've done the testing so that an e-commerce scenario works perfectly, even if you have different software platforms that the implementations are done on. And so that dialogue has been intense in the industry, particularly between ourselves and IBM. It's was very exciting last week to be able to come out and announce the WSI, the Web Services Interoperability Organization. The response to this has been pretty incredible. We have a lot of key companies as founders. But even this week, we've had an amazing number of companies join up and say, this is absolutely something we want to get behind. We want to make sure that all the vendors are building products that work this way, and that there's concrete testing that goes behind this.

And so I think that we'll look back on that milestone, the announcement of WSI, as a very, very important development. At this stage, we've got lots of companies involved, over 50 different companies. If you look up there for your favorite company, you'll see that basically everybody except maybe one company, is up there. I would say it's a quorum of the computer industry, and it's well represented. A lot of nice companies decided to join this organization.

And so, a lot of hard work ahead of us here, but the commitment of the company to this principle of interoperability really is central to making sure that while insisting that applications work this way, you'll be able to pick different software stacks knowing that those work together.

So, Microsoft is one of the companies that wants to build the tools and the platforms to make this all possible. We, in fact, about three years ago bet the company on this web services paradigm. We said, this is the new thing, and we're going to put all our energy into it. We talk about our .NET strategy, one of the key elements is this commitment around XML. It's a very profound commitment for us, it is a big change for every major piece of Microsoft software. And in the same way that you've seen with customer applications, we start with having a rich XML layer on top of our software, and then as we go to the new generation build from the bottom up around XML. So, you've seen this with products like SQL, put a very rich XML layer on top. If you look down inside, it's still relational tables, but the next major version, if you look down inside, it will actually be XML as a very central data type.

Now, some people are surprised that I say even Microsoft Office needs to participate in this. When you think about viewing information for forecasting, you want to natively understand XML. We put out an Office Tool Kit for Web Services, which allows you to have that connectivity. But as we're building those applications, things like the spreadsheet, we'll have a native understanding of XML, and it will allow the coordination of information from the knowledge worker to these back end systems to be far more effective than ever before.

The .NET vision incorporates more than just Web services. It talks about how people use these things, being able to get their information at any time, any place, on any device, pocket-sized devices, tablet-sized devices, in the car, or the TV set, you name it, all connected up to these capabilities.

And so, .NET means that we're bringing XML services in three different ways, on the client so that you can have intelligent software there, on the server, and finally sort of a new realm, which is the idea of pervasive availability of services. When people talk about needing to authenticate things in a trust hierarchy, you've got to have many companies offering those services. And so something like Passport fits into that. When you want to work on behalf of the user to decide what notifications are worth interrupting the user, and what devices he's using, you need a service in the Internet that works on behalf of the user to do that. And so those are examples of the kinds of things we'll do with My Services.

Part of it is to make sure that people don't have to get involved in replicating their files, or their contacts, or their mail, and simply that these service work to automatically bring that information to any device that they authenticate themselves on. So the entire Microsoft R&D budget is focused around these goals. It's a huge investment, over US$5 billion a year. That's an R&D budget that will keep growing because of the opportunities opened up by all of these approaches.

So, it's very simple what we're saying. Today is a major step forward in letting people build the next generation of applications, the applications designed around XML Web services. That was a founding principle of the design in Visual Studio .NET. When we started out, we said, wow, this could be one of the biggest pieces of work we've ever had to do on a tool. Usually, we like to have two-year product cycles. But this one, we not only increased the R&D, but it was a three-year cycle to get all those pieces done. But we needed to have a comprehensive capability for these kind of applications.

So, today marks the retail availability of Visual Studio .NET. It's important to point out that it's not just the tools, because although we love this tool, it's the world's most popular tool, there will actually be other tools as well that target the run time. The run times in some ways is the most profound element, and that's what we call the .NET framework. That includes this idea of the common language run time, the engine in there that does the execution and that understands the type systems and the capabilities of the wide range of languages that people use.

A big proposition here is that you can build these new applications, and you can build them efficiently. I think if you go back and look at the last generation the Web site applications people built, because they were built in a rush, the tools didn't come along at the very beginning, some of those are very tough applications to maintain, many different file types, implicit assumptions, hard to even test things like do the links traverse and things like that.

Here, from the beginning, we knew that we wanted a tool that would make applications relatively compact, and provide a lot of efficiency. We talked about, how can we actually show that a tool is very efficient. How can we show that you can get a lot done in a short period of time? The idea we came up with is to have a little contest here called the Armed Developer.

So, let's take a look at the participants, and what we're going to do.

(Contest setup.)

That should be exciting, good luck.

Bang a gong, let’s get it on.

Visual Studio .NET has a lot of new exciting things in it. The integrated development environment for all the different languages is really a first, something we’ve been talking about for a long time. And now that’s come together. In every one of the languages we see advances, in fact, as XML is coming along, we think we’ll see more language innovation over the next four or five years than we’ve seen in the last 10.

For Visual Basic developers, it’s a move up to full object-oriented programming. Visual C# is, of course, new, a very easy transition for people who have worked in C, C++, Java, and some innovative ideas that come into that language. For C++ developers, new capabilities like attribute-based programming. The richness of the tool has also been expanded quite a bit as we’ve had feedback from our enterprise developers. And so it’s the most comprehensive development tool of all time.

One of the key philosophies here is giving people the ability to work with any language that they’d like to choose. There’s many reasons for this. One reason is that people have existing code. And it’s not economic to tell people, hey, rewrite all of that code, whether it’s Fortran, RPG, COBOL, that code, if it works, you should be able to go on using it, and use it in an integrated way, where as you debug you can traverse from one part of the program in one language into the other, without losing visibility of what’s going on in your application.

Now, part of what we’ve done here is reach out to the universities. In the universities there are a number of languages that are listed here that are very innovative, and a few of those will definitely move into mainstream, commercial use. Very innovative ideas that either the entire language itself or the concept will find their way into broad commercial development. And so we went to these university developers and said, "Why don’t we give you an environment where the editor and a lot of the run time pieces are already there, and you can focus in on the language advances you want to make?" We’ve had an incredible response to that. Virtually all the different, new languages being developed are being hosted in this Visual Studio .NET environment. So it’s one integrated development environment, one framework, one debugger, and over 20 different languages that we’re supporting here, including our own Visual Basic, including C, C#, Java, you name it, it’s there.

Well, this development environment has extensibility, has the ability for new toolkits to be created that ease the development whenever you have an application that’s using a particular run time. We expect to see a lot of these toolkit add-ons proliferate. For our own products, one thing that’s new today and just being released on the Web is a SQL Server 2000 toolkit for Visual Studio .NET, and a Biz Talk Server toolkit. And so as you define a project you simply, if you’re going to use these capabilities you declare that, and a lot of capabilities come into the environment to help you do that work.

To give you a sense of why we think this is so important, I’d like to ask Scott Woodgate to come up and give us a look at these toolkit add-ons.

SCOTT WOODGATE: Visual Studio .NET is the premier development environment in the world today. What I’d like to show you is how we’re putting even more power in the hands of developers through the integration of Visual Studio .NET and our .NET Enterprise Servers. Using Commerce Server 2002 you can quickly and easily build directly inside Visual Studio .NET. What I’d like to show you now is how Visual Studio .NET can take advantage of the new XML Web services capabilities of Biz Talk Server, and SQL Server. For this demo I’m an online retailer selling Xboxes.

Some of the challenges I face are accepting orders from any device at any location, taking those orders and integrating them into my enterprise system, passing those orders to a distribution partner for shipping. So let’s take a look at how we can manage that through a single user interface and the Biz Talk Orchestration Designer. So this is the Biz Talk Orchestration Designer. Biz Talk Server orchestrates business processes and Web services. It’s the Biz Talk Orchestration Designer where we design the business process for receiving orders for Xboxes. Once we’ve received an order for an Xbox we do two things simultaneously. First, we send that to our shipping partner to this SQL database. And at the same time, we update our own enterprise ERP systems, in this case SAP.

Now, how cool would it be if I could take this entire business process and make it available as a Web service for use inside Visual Studio .NET, or access from any device, at any location. Well, with the Biz Talk Server 2002 toolkit for Microsoft.NET that’s exactly what I can do. I can take a business process from the orchestration designer, turn it into a Web service for access from Visual Studio .NET, or from any device at any location.

So let’s take a look at that. I’ve created my business process, and I’ve gone ahead in Visual Studio and I’ve created a Web service from my business process, making it available to any client for ordering. So let’s look at a particular client. I’m here designing my commerce store, and I want to add the checkout functionality to my commerce store, which of course is to pass the order to my Web service. So let’s go ahead and add in that Web service, and in the checkout page we’ll go ahead and call the Web service. So that’s all it takes to take a business process that you are creating in the Biz Talk Orchestration Designer, and make it available as a Web service.

But, what about accessing Web services from inside a business process itself? Well, we can do that too. Let’s go back to that order process. Here you see that we were talking to our distribution partner who ships those Xboxes. And to do that we’re talking directly to their SQL database. How do we do that? We’re using the new XML Services Tool Kit for SQL Server, that makes turning a stored procedure into a Web service very simple. In fact, with the SQL XML Web Services Tool Kit, turning a stored procedure into a Web service is as simple as selecting the database, of course putting in a log in, and then simply scrolling down and choosing your stored procedure. So really with the SQL XML Web Services Tool Kit, it takes turning a stored procedure into a Web service that’s something that’s very, very simple.

So let’s go and have a look at this particular one. How do we send to SAP as a Web service? Well, with Biz Talk Server’s 300 adapters, you can take any packaged application at your enterprise and turn it into a Web service. In this case we’re using one of our great adapter partners, Rational Software’s SAP adapter to talk directly to SAP. So we’ve built this business process, and we’ve built the Web services in Visual Studio .NET, let’s go ahead and take an order for our Xboxes from our Xbox commerce store. So, of course, we add the order to the cart and check it out. Our order number, order 15, is being sent through orchestration and XML Web Services to SAP, and to SQL Server. Using the Visual Studio environment of course we can now directly browse our SQL tables to determine that a new order has, in fact, been delivered to SQL Server, the order is order 15. And what’s more, if we open up the SAP sales order module, and go search for order number 15, then there it is.

So what I’ve shown you here is how we’re making developers even more productive, putting more power in their hands, through the integration of Visual Studio .NET, and the .NET Enterprise Servers. In particular I’ve shown you how it’s very easy to take a business process from the orchestration designer to turn that into a Web service. How you can quickly and simply take a stored procedure from SQL Server, and make that available to any device, at any location, as a Web service, and of course how you can orchestrate Web services as part of the business process. Both the Biz Talk Server and the SQL Server tool kits are available on MSDN, and of course at the product booth at this conference today.

(Applause.)

BILL GATES: Thanks, Scott.

What we’re talking about here is using Web services as the underpinning of how business is done. This, of course, means that the industry has to step up to a whole new level of reliability, availability, understanding needs around security and privacy. This is a key initiative, because the dreams of how these services can provide benefits won’t be fully delivered unless huge investments are made in these capabilities. Now one of the approaches that we’ve adopted in the platform, the Windows platform, is the same approach that was used in the branch of computing called fault-tolerant computing. Historically, if you wanted systems that ran 24 hours a day, you couldn’t buy just a typical mainframe or a high-end UNIX system. You had to buy systems from people like Tandem and Stratus that were premium products, and very special tools development around those things.

We made the decision that those approaches should be made mainstream, that is, that we should build into the platform the kind of transaction support and other capabilities that would make all applications work in a fault tolerant fashion. The reason being that all these Web services need to run 24 hours a day. And that approach, that we call scale out, is a great solution not only for reliability, it’s also a great solution for scalability. But, that’s just one of the steps that’s necessary to get it so we think about these Web service systems being as reliable and trustworthy as, say, the electrical system or the phone system that we’re able to count on today.

That security model is making it easy for people who build applications to think through are they providing security, making it easy for developers to think about the privacy issues in terms of how they control access to this information, and upholding a principle of users being in control of their information. There will be a lot of hard work on Microsoft’s part here, but also the applications that you develop are a key part of the picture, as well. And so I think there’s a lot of collaboration, a lot of new work to be done to deliver fully on this promise.

Let’s look at a typical application running, built with Visual Studio .NET, running on the framework, on the Windows platform. There’s an industry standard benchmark, which is the Nile benchmark used by a number of the key industry publications. We can see here that the performance from the .NET Framework approach is very dramatically improved. We can see that as we move up to more CPUs, in this case from two, to four, to eight CPUs, we get that scaling capability. And this is just inside one server. There’s another way to get scaling, which is of course to scale out with the multiple servers connected up together, and working in a way that even if one of them goes down, the work is transparently transferred over onto these other servers. So this kind of dramatic result, this kind of dramatic improvement is something that we’re seeing again and again, as people build their applications on .NET.

In fact, inside Microsoft I thought I’d have to push groups to rebuild their Web servers around .NET. That’s often true when we come up with a new approach. In this case, once the word got out about how effective it had been for the first few Web sites that had been rewritten this way, it caught on like wildfire. In fact, today all the new Web sites we build, literally dozens and dozens of them, are built on .NET, and we’re seeing the performance and reliability benefits very directly ourselves as a user.

Over the last six months, as all these things were becoming final, we were really amazed at how many customers came to us and said they wanted to go ahead and release Web sites built on the run times. And so we came up with a special agreement they could sign and go ahead and do that release, part of which says that we would like you to upgrade to the final bits at those become available. So amazingly, we had over 6,000 customers sign up for this early release program. You can see some of them listed here, and actually visiting these Web sites is one way to see that they’re actually getting a lot of richness into what they’re doing that wouldn’t have been at all easy for them to do before.

Well, this is something we’d love to have you see a couple of the really hot things that have been done, taking advantage of the platform. So I’d like to ask Ilya Bukshteyn to come up and show us what’s going on with customers using .NET.

Welcome Ilia.

ILYA BUKSHTEYN: Thanks, Bill.

Good morning. As I’ve had the opportunity to talk to some of you this week, and to hear first hand how you are starting to personally experience the sheer joy of developing with Visual Studio .NET, it’s been incredibly exciting for me to see the results that your efforts are having for the companies that you work for. We’re seeing companies drive tremendous benefits in time to market, productivity, and their ability to operate very large applications when they go to .NET.

Now today I want to talk to you about three customers that have made the .NET bet, and have already deployed and realized significant benefits. These customers are in a variety of industries, a variety of business models, but they have two things in common. One is that they are a leader in their industry, whether it’s the number one beauty and cosmetics company in the world, or one of the most well recognized names in financial services, or the leader in graphic design software, the other thing they have in common is that they have used .NET in creative, interesting and amazing ways to create the next generation of applications. And they are seeing, as I said, business benefit today from those applications.

So I’d like to start by talking about a business that I have to admit I knew very little about, the beauty and cosmetics industry. And it turned out that this industry is ferociously competitive. Time to market is absolutely key. And L'Oreal have used .NET to do some amazing things in terms of time to market. Let’s take a listen to their story.

(Video)

ILYA BUKSHTEYN: Well, there's two things that always jump out at me when I hear L'Oreal tell their story. One is that I can't believe I missed the meeting invite for some of the shots in that video. And the other is the sheer scope of the time to market advantage that L'Oreal were able to recognize. L'Oreal have a tremendous number of brands, and a significantly bigger number of Web properties around the world. They were able to develop their first e-commerce property, the Lancome France Web site in about four months. They are now going live with a new site in a different geography and a different language about once a month. That's a 300 percent improvement in their time to market from their previous technology platform, and that's an improvement that goes right to the bottom line.

Let's move on to our next customer, in yet another extremely competitive, the financial services industry. Merrill Lynch were facing some very tough challenges as they looked to provide leading edge customer service to their users. Let's take a look at what they came up with.

(Video)

ILYA BUKSHTEYN: Well, Merrill Lynch, as you heard, is facing a very significant business challenge. They had to integrate all of their legacy voice response customer service systems so that they could provide a next generation customer service experience to their 25 million users. So, from a business perspective, they wanted to have the best possible service for their customers. They couldn't afford a customer to call up and hear "system temporarily unavailable." From a technical perspective, the challenges were 24/7 operation, integration of a variety of systems from the host on up, and a flexible platform that would allow them to maintain a high level of customer service by rapidly deploying new features.

So, what Merrill Lynch have come up with is the new 1-800-MERRILL voice response customer service system. They're very excited about the benefits the system is going to provide to their business and to their customers, and their customers are very excited about having this new tool to be able to manage their finances with Merrill Lynch.

So, I'm sure you're all dying to hear what Merrill has actually created. I'm going to go ahead and call a number Merrill Lynch has set up to pilot this new application until 1-800-MERRILL goes live to all of their users next month. So, let's go and take a listen.

(Call placed.)

ILYA BUKSHTEYN: Well, hopefully two things were obvious from that phone call. One is that my account is kind of hurting. But the other is the breadth of service that Merrill Lynch customers will be able to have in this new customer service channel. So, how was Merrill Lynch able to get from their host systems and their legacy systems to this new integrated single customer service channel? For Merrill Lynch, the answer lay on a three-tier architecture using .NET to build a set of Web services, using SQL Server 2000 to add additional data on top of that stored in their host. And, lastly, using .NET, specifically ASP .NET, to provide a flexible interface to the system, so that it can be voice response today, but it can be expanded through a variety of different channels as the market demands it tomorrow.

When this infrastructure goes live next month, Merrill Lynch are going to be depend on it to support 25 million users and 75 million transactions a day. 1-800-MERRILL is proof that VisualStudio.NET and the .NET framework are truly the best operational solutions for mission critical enterprise systems.

Well, we've been talking for a while now about enterprise customers building complex systems. But, of course, enterprisecustomers needs great tools and great partners to build these systems. So, before we talk about our partners, let's check in on two of those partners, the Iron Developers.

(Video)

ILYA BUKSHTEYN: I don't know about all of you, but I spotted at least two boxes of Krispy Kremes, and four slats of Frappicino, so I'm betting whatever they come up with is going to have a lot of rapid animation. I can't wait to see what they come up with.

Meanwhile, let's talk about another one of the partners that are doing amazing things on .NET. Autodesk are the clear leaders in the graphic design, imaging, and GIF software industry. And they've really used .NET to help their developers and, in turn, their customers become dramatically more productive. We'll take a quick look at what they've done.

(Video.)

ILYA BUKSHTEYN: I think Autodesk put it best when they said with .NET seeing is believing, working with it is really believing. So let’s go ahead and take a look at what Autodesk has built.

What you’re looking at is a .NET framework application that Autodesk has built to demonstrate what they’re doing on .NET. This is a Windows form application, which is a visualizer for various graphic data types. So by the way, when they told me I’d be doing a keynote that had L'Oreal in it, and that I’d be working with beautiful models I kind of pictured something else, but I’ll work with this for now.

So I can do some advanced work in here, such as take a model, what we’re looking at here is a topographic map of the U.S. with details such as state borders and roads, and I can of course do some of the things you would expect like move it around, a little bit more advanced functions like zoom in. And what I thought I’d do today is zoom in on the Bay Area. Let’s have a closer look.

Now while I’ve been here I’ve actually enjoyed this area so much that I thought about maybe buying a house here so I can spend more time. And the folks at Autodesk have told me that there’s a new development right by their office that’s looking really good for some great housing. Hopefully it will be affordable housing, based on my account balance. So I’m going to go ahead and zoom in on the Bay Area, and we see the folks at Autodesk have been nice enough to point out where the development site is. And I’ll go ahead and zoom in on that. What this application is doing behind the scenes is actually pretty amazing. It’s opening up files that contain real information in various formats, and those files are anywhere from a meg to several megabytes worth of numbers in XML format. Of course, the end result looks a lot better than XML, it looks something like this. This is a very complex, multilayered diagram that shows the area around the Autodesk offices, and our proposed development site is right here. And not only can I do things like zoom in, but if I wanted to see, you know, is it a flat piece of land, I can also do things like orbit, so I can see, hey, there’s kind of a hill right here.

So let’s go ahead and take a look at the specific development site I’m interested in. As I’m doing this, this application is using Windows forms, and DirectX to take whatever format the data is in, whether it be Land XML, or other formats, and render it on the fly in a very high performance way.

So as I said, some of these files are multi-megabyte, and they are real representations of the terrain in the specific area. So it’s actually a real piece of land right next to the Autodesk offices. So here’s my land XML file, and the nice thing about this particular representation of the area is if I’m looking at it this way I can’t really tell, is there a big hill, is there a small hill, but I can do an orbit to show me, wow, that’s actually a pretty good sized hill right next to my development site. So that’s going to work well for mountain biking, and hiking.

So now I’m sold. I want to go ahead and get a property right in this site. So I’m going to go into the highest level of detail, and take a look at the specific lots of land that are available. And again, I can zoom in, get a lot of detail, right down to the street names. And I might as well dream, I’m going to see if I can get a waterfront property. What we’re seeing her is my dream house. There’s my house. Now, it happens not to have walls, because I want to see what it’s going to look like inside. But, there’s the front of my house, there’s the back of my house, and if I wanted to be safety conscious I could see what my house would look like in a tornado. There’s my house.

Now, the key point is not what you can do in this type of application. I know a lot of you are probably thinking what I first thought when I saw this, which is that’s cool, I know it can be done, after all, we have the Xbox, we know we can do amazing graphics, but as a developer I would have to get up pretty early in the morning and eat my Wheaties for a lot of days in a row to be able to do this kind of super rich application.

Well, the folks at Autodesk have taken Visual Studio .NET and created a GIS toolkit for .NET that now puts this kind of rich application within easy reach of every Visual Studio developer. So let’s go ahead and take a look at that. What you’re seeing here is Visual Studio, but if I go to a new project you’ll see that this has the Autodesk visualization toolkit for .NET installed. So it’s now as easy to do a new GIS application as it is to do any Web or Windows application. So since I’ve chosen the GIS application type I get this new Wizard that Autodesk has developed. I can go set a lot of the features in the wizard to determine what my application is going to look like, but for today I’ll just accept the defaults. And as this wizard completes I actually have an application that I could run right now that would allow me to do a lot of rich two-dimensional and three-dimensional functionality.

Now, since most developers don’t just click finish on a wizard and run an app, I’ll go ahead and add some functionality. So for instance, let’s say my users have already crated graphical designs that they want to be able to open. I’ll need to add an open file dialogue. As you can see here on the tool box, Autodesk’s toolkit for .NET includes a lot of the drag and drop components that developers need to build these rich applications. So I’m simply going to take their special GIS open-file dialogue, drag it and drop it on my design surface. And now I need a way for users to get at that dialogue. So I’m going to go to my menu, I’m going to add an open entry, and I jut double click on that to get into the code. And now all I need is one line of code, and that one line of code linked my new open file dialogue to my application. So now I have an application where I can go ahead and open a design file, and with those few clicks, a wizard, one line of code, and some drag and drop, I now have an application where I can do some of the same rich functionality, like zooming and even orbiting, so I can see the exact shape of this piece of land.

With a few easy clicks we’re already starting to see an incredibly rich client application take shape. So we’ve seen huge improvement in developer productivity, operational excellence at a true enterprise mission critical scale, and time to market advantage that really hits the bottom line. These customer examples are living proof of the benefits all of you can realize today by using Visual Studio .NET.

But wait, there’s more. So to talk about the last partner that we want to show you today I want to invite back on stage Bill, and he’s going to be joined by Grady Booch, chief scientist at Rational Software.

(Applause.)

GRADY BOOCH: Let’s slam out some code here. Rational Software provides development tools for the entire life cycle, enabling teams to build better software faster. Today I’d like to show you the deep integration of one of our tools, Rational XDE, with Visual Studio .NET. Something curious first here, here we are inside one of Microsoft’s reference applications, this happens to be IBuySpy, a classic retail portal. Let’s put an item in our basket, we’ll take the mustache transmitter, my favorite, check out, submit. You’ll notice something curious here, that I can buy things, but I never have to pay for them. So this site is losing money on every sale, not a particularly sustainable business model.

So let’s suppose that we as code warriors are tasked with the responsibility of adding some new functionality to this site, to enable visitors to put in credit card information. So we’re going to push back the curtain and look at the underlying implementation. Here we are in Visual Studio .NET, looking at its code base. By the way, for those of you who are familiar with agile methods, what we’re doing here is para-programming. So help me out here along the way.

If we look to the underlying implementation we’ll see that this is a classic three tier implementation, a variety of components to do conversations with SQL Server. There are a number of other components here, and indeed this one looks particularly promising, in fact, this is the place probably where we want to put in some credit card information. If we look at the code base behind this, again, we can see a variety of classes, in this case it happens to be here in C#. Now, it’s always difficult in dealing with a foreign code base to understand its complexity. But, you know, sweeping away that complexity can sometimes happen by looking from an entirely different perspective, and that’s where Rational XDE comes in.

We’re going to take a look at a blank drawing surface here, and we’re now in the model explorer. Notice the tight integration. We see the same classes as before in the unified modeling language as we saw in the code base. In particular let’s take a look at one of those classes, the check out class, drag it, drop it, put it here, and we see the same rendering as before, no class is an island, so we want to take a look at all of its neighbors. Bring up a dialogue to do so. It’s blasted through the model to find them, and now let’s auto layout, and we see the entire model here. And let me clean this up a little bit, because it’s kind of difficult to see. And here is the same model. We see the check out class happens to be a subclass of page, thereby inheriting all of its properties. There is the data grid we saw earlier, ultimately manifesting itself in the C# file.

As is typical with any object oriented system, we want to add new responsibilities, and so let’s create a class that allows us to do so. We will apply the power of modeling here to go to create a class. Let’s call this thing transaction client.

GRADY BOOCH: I'm just going to drag and drop that here. Now, here we've got the class, I could spend some time in the modeling level, but you know let's synchronize this thing with our underlying code base. Here we are, and we go back to the solution explorer, and we see the code for it living right here. You know, the best way to avoid risk in software development is to simply not write any code at all. True. And that's where the power of patterns comes in. A pattern is effectively a common solution to a common problem in a context. And Rational has a set of those that we provide in what we call Development Accelerators. We have such an exemplar here.

This particular pattern involves a conversation between a simple client and a container, but that's a static piece of it. Let's look at the dynamic piece of it, which is more interesting, because we see here this conversation going on between those two classes and our underlying Web service. So, what we'd like to do is imprint that pattern upon our application. So, we can do so easily, we'll select that pattern, here we are. Let's bring a pattern wizard. And it's going to walk us through a process of imprinting that pattern upon our model.

So the first thing I'm going to ask for is, you know, give me the client in which I put this in. So, let's select it, we created that earlier, the transaction client. It next asks for the container, we check out class -- whoops, let's go back, I screwed up, cancel that guy. Try again. I'll find a pattern. Here we are. Ignore the man behind the curtain. Let's select the client first, here we are, next let's check the container next. And now it asks for a name space. And we're basically done. And you'll see it slamming that pattern and printing it upon our model here. And, in fact, we see the transaction client has been updated.

In fact, if we look at the check out class, look at all its related shapes again, we'll see that, in fact, the relationship between those has been maintained. Earlier we saw, we had the transaction client code here. Let's bring those things into synchronization. We're going to select the transaction client here, we're going to select also the check out class, and we'll synchronize our code so that we're, in effect, blasting the pattern code into our underlying model. And that wasn't me typing really fast, it was the pattern blasting into it.

Now, we're almost done. We have one last thing to do. Now that we've wrapped up the middle tier and the bottom tier, let's go to the presentation layer. We saw the check out class earlier. We're going to bring in one element here. Let's take this set of forms, drag them and drop them here. Look at the code behind the check out class, and we need to add one declaration so that things are now known, and now let's cut some code here and build the system again.

So, very rapidly, we're building a new application through the power pattern, to the power models, here we are inside I Buy Spy again. Now, this time let's put something in our shopping cart, let's go with a non-explosive cigar. We'll do a final check out. We see here it's now asking us for credit card information. In fact, there's behavior behind it. I haven't done anything, so let's put something in. I didn't bring my wallet, can I -- never mind. Let's do something else here. Let's just pick something bogus, we put it in. Oops, it wants a real number. Boom, we finally are making money on this site.

The power of modeling, the power of patterns, the power of Rational XTE with Visual Studio .NET, friend, this is how one builds better software faster.

Thank you.

(Applause.)

BILL GATES: Amazing to see how that all integrated in such a powerful way. We have a couple of new announcements, people who have come along to support both the framework and Visual Studio .NET. First, two people supporting the framework are Borland, adding their C++ and Delphi support targeting the framework. Macromedia with their high end Dreamweaver UltraDev, likewise targeting the ASP .NET framework. And then several companies doing add-ins, like we showed our Biz Talk and our SQL Server add-in, IBM with the add in for DB2, Computer Associates with the add-in for their management capabilities, Group Networks with their enterprise collaboration tool, and finally SAP allowing you in the Visual Studio .NET environment to connect up to the R3 business applications.

So these are very important developments. The specific capabilities they enable are important, and they are a great illustration of the momentum we have behind this problem. We have now over 190 developer resources, developer add-in capabilities that have been made available. So the momentum really has been building over the last year. In fact, some of the statistics around Visual Studio .NET are quite amazing. Certainly, this is the most awarded product before shipping with four major awards. People couldn't help it, they were just so excited about doing it. The beta has been 3.5 million users, which for a developer product is quite unheard of. Over 800,000 developers building sites. I mentioned the tools; the books are another good indication of what's going on here. And lots of user groups where people get together and talk about the new things they're doing, where they're going with Web services, and how they use this tool to do it.

Now, one area that is very important to us is working with high schools and universities, working with the education sector to make sure people get early exposure to this, and so they know these methodologies as they come out into the marketplace and are coming along to build applications. This is something we've always believed in. But here with .NET, it's a particular opportunity to get not just the academics, but the students involved in a very rich way.

I would like to ask Chris Flores to come out and talk about some of the things we're doing in the academic world.

Good morning, Chris.

CHRISTOPHER FLORES: Good morning, Bill.

(Applause.)

Thank you.

So, creating great software isn't the only thing that we're passionate about at Microsoft. We're also very passionate about education. And it's through our academic alliance program that we are working very closely with teachers, and faculty to ensure that they have the necessary tools, skills and resources to successfully take their students through the digital decade which lies ahead.

Through this program, we work very closely with over 800 institutions, ultimately reaching out to more than 200,000 students. Now, to really see the benefit of this program, you don't have to look any further than right here in the San Francisco area.

Not too long ago, several students within the Monte Vista High School located in Danville, California, looked around within their high school, and they saw problems. Problems that they knew they could solve using Visual Studio .NET. I'm very pleased to announce that we have some of those students here today. So, please give a very, very warm welcome to two of the engineers of the next generation Internet, two young Iron Developers in the making, Neil Chopra and Gregory Hannum.

Welcome.

(Applause.)

BILL GATES: So, tell us, what did you and your team do?

STUDENT: Well, we designed a program here that will help school systems keep track of students' grades, help keep the teachers organized, and allows parents to track their students' progress throughout the school.

STUDENT: Welcome to Grade Scope. This is a Web application written in C#, and is powered by ASP .NET. On the backend it uses SQL Server 2000. I'll just log in as a student. Grade Scope automatically detects whether you are a student, teacher, parent or administrator. The layout of this page shows the assignment name, any points you've earned on a particular assignment, and the due date if provided by the teacher. Grade Scope also automatically detects, as you can see, if an assignment is due the next day.

On the left is a user controls with a clickable list of classes, so students, teachers or parents can quickly change between the classes they're viewing. Also, there's a drop down list of four quarters, so they can change the view of their progress.

Now, the progress page for students gives them a snapshot view of their current progress, here with this preliminary report card, they can take a look at their work ethic, and divvy up their time differently if needed.

Now, Grade Scope provides the most functionality for teachers, let's log in as one.

(Applause.)

NEIL CHOPRA: The default page for teachers is the assignments page. Here they can add, edit, or delete assignments. Adding a new assignment is very easy. The fields available is the assignment name, an optional description, and assignment number that can be taken up to two decimal places in order to maintain ordering. They can also choose the assignment type which helps if they enable assignment weighting, which is one kind of assignment type that may count for more than another. Visual Studio .NET also provides us with a calendar function that we were able to use in order to give teachers more of a visual idea about when things are assigned and due.

Now, the page with the richest functionality is the grades page. This is where a teacher can make or break a student's grade. Each column represents a different assignment, and each row represents a different student. Across the bottom, you can see that the class average is shown for each assignment. This allows teachers to see how the class worked as a whole on a particular assignment. Now the green and red Ps you see on top is a feature we implemented called Publishing and Unpublishing. Here, if a teacher is not finished grading all tests, or students haven't turned in all their homework, they can still enter the data, but hide it from the student's view. Once they're ready, they can post the grades, and it will be part of the student and parent's view.

Appended to the right of each student name is their semester grade, and also an optional comment that a teacher can add or edit for any student. This comment can be viewed by the student or teacher. With the help of Visual Studio .NET, Grade Scope has developed into a functional school-wide ready application that ca be used by any parent, teacher or administrator who has a computer with Internet access.

Our latest and most exciting development has been the integration of mobile Internet access.

Greg.

GREGORY HANNON: All right. In addition to the Web page, using Microsoft Mobile Internet Toolkit, we designed a system that allows PDAs and cell phones to check your grades or upcoming assignments from anywhere in the world.

(Applause.)

Here we have an emulated system in which we're already logged in. There's a couple of menu options, you can choose the first one here for grades, and then within that is a list of all your classes. You can pick one of those, and then pick the quarter. Now, we're presented with a list of every assignment within that class and quarter, the current due date for that assignment, and whatever score was received on it. This is very helpful if you're dying to see what you got on that last test.

In the other menu, the progress menu, we can choose the semester, it will show us a report card of everything we've gotten so far for each class, which allows us to dedicate our time to one class or another easier.

Overall, Grade Scope is a little more than halfway finished, and thanks to Visual Studio .NET it’s been extraordinarily easy to program, and we plan to continue working on it until its completion.

(Applause.)

BILL GATES: I’ve always believed in starting development young. Tell us a little bit about your team and how long it took to get as far as you are?

STUDENT: Actually, it was really surprising. We have a five member team, and we had only five weeks to do this. During that time we also had finals, and a number of competitions and events, so personally I was surprised at how far we got. Visual Studio helped us move through very quickly, and it was just amazing.

BILL GATES: It’s great to see what you’re doing. Thanks for coming.

STUDENT: Thank you.

CHRISTOPHER FLORES: Bill, I think one thing we should mention is that we actually have the rest of the design team here today. So to give credit where credit is due, I’d like to have Megan, Vladimir, and Mike, as well as Roseanne, their tireless dedicated teacher, please stand so we can have a nice round of applause.

(Applause.)

CHRISTOPHER FLORES: You did a fantastic job, guys. Thanks very much. You can leave your resumes at the door.

Well, Bill, I think the time has come. Our Iron Developers have been feverishly coding backstage, and I think it’s time to bring them out, so the audience can help us choose the greatest Iron Developer.

BILL GATES: Welcome back.

CHRISTOPHER FLORES: How are you guys feeling.

??: Tired. It was a long hour.

CHRISTOPHER FLORES: So none of these high school kids helped you out back there?

BILL GATES: Five weeks, please.

CHRISTOPHER FLORES: Okay. So these guys have been feverishly coding for about an hour or so. All we gave them at the beginning of the hour was a copy of Visual Studio .NET, a copy of the Web site that you currently can’t see on the screen here, that we’d like to show on this monitor if we could. Thank you very much.

So we gave these guys this Web site that allows people to configure and order t-shirts. Every developer, of course, needs t-shirts. But, the one thing that this Web site currently does not do is that there’s really no way to track customer orders. And that’s what these guys have to do. We tasked them with having to track, and report, and print customer orders, and we also forced them to make it mobile, as well.

Tim, your application is done, right?

??: You’d better believe it.

??: All right. Let’s see what you’ve got?

??: Okay.

??: Pay close attention, because we’re all going to be voting on who has the best application towards the end.

??: So when you only have an hour to build an application it’s extremely important not to write a lot of code, but to use the power of the tool you’re using, which in this case is Visual Studio .NET, and I believe I’m going to show you in the next two or three minutes, especially for you developers who have not seen Visual Studio .NET yet, just how powerful this tool is.

??: You can see, I’ve created three projects within my solution. I’ve created a Web service. It goes out to SQL Server, and I retrieve data, and I also write data back to SQL Server. But, I also wrote a Web forms application. And in the Web forms application I consume the Web service, and that’s the code you’re staring at here. I instantiate it, I call the get data method, and that is merged into an ADO.NET strongly typed data set. Once I have that XML in a typed data set, I simply bind it to my data grid. Once I’m bound to a data grid, this is where I get all my power, and I can simply click, drag and drop, do properties, et cetera.

So let me run the property builder and I’ll show you just how much I got for free. Here’s my binding code. But, look in the column, I’ve got edit, update, cancel, capabilities, and I basically got this for free with just a little bit of code, two lines in the cancel, and the update simply is calling the Web service.

Let’s take a look at the app. Let me do a little editing here. All right. That called the Web service, and updated SQL Server. Now, you may have noticed in the property builder that I used the select button. With simply four lines of code I can filter out the orders that are appropriate for each customer. That’s pretty cool functionality. Except, do I have a UI design flaw here? I don’t think so, my friend. Check that out, you Web programmers. That was done, is that cool or what, come on. That was done with 20 lines of code on the client side. Very cool functionality.

So I’m back there with all the time I had left, and it turns out some of you in the audience, some of my friends out there are using wireless mobile devices, and insulting me with instant messages. Tim, you suck. Tim, you look just like Bill Gates, except your short, and more stupid. You may have seen from my test data that I made that person pay. Maybe I should switch back.

Anyway, in my third application is a mobile application. And I have a mobile Web form. The controls are similar, and slightly identical, but the code, I basically pasted right into my mobile Web form and I’m ready to go. Now I have two applications. One that gets the broad reach of hundreds of cell phones, and PDAs, and such, with Microsoft Mobile Internet Toolkit, MMIT. So let’s take a peek.

Here we go. Some of these devices may be strangely familiar to you. I believe I can do that, and do this. Got to go to the keyboard on this, no mouses. All right. I can switch over to here, and boom, there’s the same data. Very cool. There’s Bill, his orders. Let me back up, show you the orders themselves, the details of it. Back up. All that I got for free.

Let me sum it up for you. That’s 50 lines of code on the server side, 20 on the client side, and I’ve got an application with broad reach, two applications. If that is not a testament to how powerful, and how cool this tool is, I don’t know what is.

Take that.

??: Win 32 boy.

??: John, that’s some pretty cool stuff. Do you think you can top that?

??: That’s a nice little application, I’ll give you that much. Keyword little application.

So I think a similar, but far superior approach to what Tim did, what we’re looking at here, I also started with a Web service. So what we’re looking at here is the helper page created for my Web service. I’ve got two methods, one to get data, one to update data. We take a look at my get data method and scroll down here, you can see that what I’m actually returning out of this method is a strongly typed data set. So what I’m using her is the .NET framework’s ability to take an object like a data set, serialize it to XML, and send it back in a SOAP compliant response.

If we take a look at the code I wrote to build this Web service, here’s the Web service in the designer view. I’ve got three SQL data adapters on my designer. Now, SQL data adapters are server side components that are designed to not only allow you to retrieve data, but also update data sitting in a SQL Server database. So I’ve got three adapters here, one for customer information, one for orders, and one for order details. Now, once I have my adapters in place the code required to return those to the caller is very simple.

You see here, I’ve got four lines of code up on top. First I create a data set, and then I fill each of the tables in there using the appropriate adapter. Once that data set is populated all I have to do is send it back out of my method, and the framework will take care of turning it into an XML response that can go into the SOAP message.

One of the things that we’re always challenged with when building server side applications is how are we going to monitor the performance of our applications, are they performing the way we need it to? So I went ahead and went a step further and added a perf counter to my Web service. You can see here I drag and dropped a performance counter onto the designer, and now with one line of code right here I’m incrementing that counter. That exposes the number of requests coming into this method from a performance counter. So we can take a look at that just by invoking my Web service. Let me scroll back up her. I’ll invoke it, you can see the XML that comes back, so this is an XML representation of my data set. And I can refresh this a couple of times, jump over to the perf counter here, and you can see the bar is spiked up when I refresh that. So with one line of code I’m able to implement a performance counter.

Once my Web service was done I decided that I, unlike Tim, was compassionate to my users, I wanted to build them the best interface I could, so I went ahead and built a Win Form application. What you’re seeing here is a grid with that data set bound to it that came back from the Web service. I’ve got all my customers here, I can drill down on an individual customer and take a look at Chris’ orders. I can drill into the individual order and take a look at the details. Now, the grid is editable, so I can in here and correct mistakes like in the user’s name, save that, and the next time that I connect to the Web service, when I close my application down, all those changes will get applied back to the database.

Now, I also wanted to provide my users with some reporting capabilities. So what I’ve done here is built a crystal report that allows you to see sales broken down by customer. You can see our customers here. If I wanted to see the detail behind this particular customer I can double click on that bar on the graph and see the details behind it.

??: You know that I did ask for this application to be mobile.

??: You asked both of us? I didn’t forget.

So what I’ve done is I’ve actually enabled this application to run in two modes, online and offline. What you see here is my application is going to detect that the Web service is not available and ask me if I want to run in offline mode. If I say yes here my dialogue box will fade away, using a GDI effect, nice.

(Applause.)

??: I didn’t see any GDI effects in his code. Now I have ht same functionality, I can drill down, I can look at the customers, I can look at the orders, I can take a look at my crystal report. And I can actually go in here, and I can change information, and the next time I connect back and run when the Web service is available those changes will get synchronized and applied back to the back end database.

(Applause.)

CHRISTOPHER FLORES: Very cool. Thanks guys. Great stuff. Pretty impressive what you guys can actually do in an hour.

So the time has come. The time has come to pick one of you guys. Only one of you is going to walk away as the Iron Developer of 2002. So just to show you that the applause meter is live, let’s have a round of applause here to get that meter going through the roof.

(Applause.)

??: So how many people like Tim and his Web form application with mobile access.

(Applause.)

??: And I hope you’ve got some friends out there.

??: We’ll find out.

MR. : How many people like John, Web form -- 

(Applause.)

CHRISTOPHER FLORES: Ladies and gentlemen, our latest Iron Developer.

Nicely done. And to deliver the coveted Iron Developer belt. Good job guys.

Bill, thanks for having us.

BILL GATES: Good work, you guys.

Well, that was exciting. I wonder what the runner up prize was.

Well, let me just wrap up here by saying how important we think this milestone is. Web services are the key to productivity that will span the entire economy. Visual Studio .NET is the first tool that’s been written from the ground up to allow people to build these applications. With the Windows platform, particularly now with the .NET framework running on top of it, we’re committed to provide the very best platform, with the trustworthiness, the scalability, and reliability for these online applications.

And so overall there’s a simple summary. We’re committed to help you build this next generation of applications.

Thanks for coming.

(Applause.)