Remarks by Bill Gates and Hillel Cooperman on the "Longhorn" version of Windows at the Microsoft Professional Developers Conference 2003

Los Angeles, CA. October 27, 2003 -- Microsoft chairman Bill Gates introduced a future version of Windows code-named Longhorn and due in 2006 at Microsoft's Professional Developers Conference (PDC) 2003. The following is a transcript of remarks by Bill Gates and Hillel Cooperman.

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

BILL GATES: Thank you. Well, welcome to the "Longhorn" PDC. We've been looking forward to this event for a long time. It was fantastic to see the response to this event. Of course, this is a year where most computer-related shows are a lot smaller than they were in the past, and so we weren't sure what to expect when we put up the sign-up for this PDC. We were amazed that this is actually a record PDC. We had more sign-ups than we've ever had for any PDC. So thanks for your response. It's great to see you all here.

When we picked the theme we didn't realize how apt it would be, that is, "Making the Connection," so I want to thank you for your patience in terms of all the travel problems that took place yesterday getting out here. I know there are still some people who will be filtering in over the course of the day because of those travel challenges.

Looking back, the PDC has really ushered in a lot of very important milestones. For example, the PDC in 1992 was really sort of the 32-bit PDC. The PDC in 1996 was the Internet PDC. The PDC in the year 2000 was the beginning of the idea of XML and Web services coming to the center; it was our .NET PDC and it really got that all going.

Well, there will be no doubt what this PDC is about. It's about some imperatives to make software better today, it's about a wave of software that comes out next year, but then it's about the next generation of Windows and all the things we're doing around that to make sure that brings computing to a whole new level.

The industry has gone in many waves, the original PC wave, the graphics interface, the client/server, then the Internet, and a lot of people nowadays are sort of pessimistic about what technology will bring. Of course, we couldn't disagree more with those people. There's no notion that we've reached any limit. In fact, as I'll describe, we believe this is the decade where digital devices will be a part of our lives and the economy in a very deep fashion and we have not had that in the past. The productivity, the benefits, the opportunity for software developers is stronger in this decade than in any other decade.

So this next wave is being driven forward. I'll talk about the hardware advances that are equipping us for this next wave. I'll talk a lot about the Web services capabilities. That idea of connecting software anywhere on the Internet to talk to other software anywhere on the Internet, and do it in a very rich way, we see that as fundamental. The new applications will have that at their heart and soul.

Certainly we believe in this next wave, and we're not just saying that, we're showing with our investment level how sincere we are about that. Over the last four years Microsoft's R&D budget has more than doubled, and that budget is focused on the things you're going to hear about today. It's focused on making "Longhorn" real, and all the milestones that get us to that point.

Now, why is it that some people are questioning how fast technology will move forward and the benefits of it? Well, certainly we have a different economic environment. It's not the time period where everybody has to do a Web site without even asking why, where every company has to just drive forward and use the latest technology.

Technology decisions are based on the expectation now that they're justified by business value and that's a much healthier environment, that's the environment we'll probably have the rest of our lives, and so it's good.

As we're going to IT departments, they're saying to us, "What can you do with software to save us costs and complexity in order for us to take resources and apply them to these new activities, whether it's wireless, Tablets, Web service applications?" They want to drive forward with both savings and driving into these new projects.

There's a lot of things that during the late '90s people didn't seem to be as concerned about: the number of moving parts, the difficulty of keeping things up and running, that now they're very, very focused on those things. Certainly in terms of the fundamentals the issues around spam, the issues around security, viruses coming in and causing down time, those are very prominent in people's minds.

And so unless we show that with software we can reduce those problems, make them not be significant problems, we won't be able to drive forward. So in a sense you can think of those as headwinds.

We also need to make the key advances. The boundaries we've got between different devices, between the structured world of information and the unstructured world of e-mail and communication, that boundary is too difficult. We don't have model-based approaches where we can just inspect software and understand exactly what it is and what policy it should be executed under.

So breaking down the boundaries, and meeting these high expectations on the fundamentals, will drive us forward.

I mentioned security as a very key element of that, and the theme that Microsoft is using to show how this is a critical area for our entire industry is Trustworthy Computing. Certainly there's a lot of things that Microsoft has to do. In terms of inspecting our code, making sure the APIs aren't vulnerable, doing that with some new static analysis and improved tools, that's a very important thing. Having testing methodology so that whenever systems are improved, you understand whether or not there could possibly be regressions against the applications that are out there, some technologies that allow that to be done extremely reliably and very quickly have had to be invented; those are very important. So the whole perception nowadays is around is this really changing.

We have a number of things that are weak links in the security picture. Passwords over time will not be adequate to deal with critical information. The fact that e-mail, you don't really know if it came from the person it appears to come from, and even the fact that Internet packets can be spoofed, so at many levels of the standards that we have we need to add security capabilities.

We've been very focused on this and, in fact, just a few weeks ago at our Partners conference, Steve Ballmer laid out a roadmap that talked about the things we're doing even in the very short run to change security vulnerabilities. In addition to driving the code quality forward, there are two very important techniques that Steve talked about. The first is making sure that when there are critical security improvements to software, that those are propagated very rapidly and to a very high percentage of systems. Certainly we've done a mea-culpa thing that we did not make that easy enough. People whose software was up to date did not experience the problems because the problems were engineered seeing actually the fixes that we did as we or other people notified us that there were things that we needed to update.

And so getting updating to be commonsense is very important. With the Windows XP SP1, we put in the auto-updating capability. We hope that all of you are taking advantage of that. We see that as extremely important.

We are making substantial changes to auto updating. The size of the patches, making sure that only the critical security things flow through, and the way we check to make sure we're not having regression, all of those processes are undergoing additional investment and substantial improvement.

The other technology that's very important is firewalls. And when I say firewall, I mean that in a very broad sense: I mean scanning files that come through e-mail or FTP, I mean being able to look at a machine that's been connected up to the Internet and, when that machine VPNs in, being able easily to scan it to make sure it doesn't have a problem and that software is up to date, or perhaps taking that same machine and carrying it in to the corporation and connecting it up, then it's behind the firewall and again that needs to be scanned.

So we have an update to the client that turns the firewall on by default. It's got changes in Outlook Express and IE for safer e-mails and browsing. It uses some of the new hardware features in the newer chips to block a large class of exploits. It changes the way we do some of the code protection. We recompile a lot of the key modules. That goes into beta later this year, SP2.

And then on the server, a lot of these being able to catch the cases where you need to scan, remotely or locally, and then simple configuration where you can say what the type of the server is, and have all things locked down according to exactly that use, again we'll beta that in the first half of next year.

So think about firewall and updating as two key areas that we're going to make sure that those are done very, very well, and give people tools to make sure that they won't have any problems because they're applying those techniques.

One thing that's been amazing at Microsoft is the impact that our monitoring data has had on how we prioritize our software work. I'm sure you've all seen in XP that whenever an application or the system malfunctions you get the ability to send a report back to Microsoft. We get a lot of those reports and we've created very good data-management systems to go in and look at those things and therefore understand what drivers aren't reliable. We have really changed our relationship with the video-driver people because, as we noticed that some were quite unreliable compared to others, we've talked with the manufacturers who buy those video drivers and hardware and said, "Look, we've got to work together to drive several orders of magnitude additional quality into this part of the system." So between Microsoft, the manufacturers, the video companies, that happened.

I've got here a chart of a network piece of software that when it first was being monitored under our system it had a lot of crashes taking place. And as they got the data from us, analyzed those past updates through an updating infrastructure, including Windows Update, the improvements were very, very dramatic there.

We allow anyone who has an application that runs on Windows to sign up and get the reports that relate to their application, and we've got the winqual.microsoft.com where people can do that.

Today we've seen a lot of that activity from the driver manufacturers, but we want to see even more at the application level so it gets us working together on anything where a user is not having a great experience.

Recently with the Office 2003 we extended this idea of getting feedback data to go far beyond just malfunctions. We extended it to messages that might be cryptic or long delays or help information that wasn't helpful, and now we're monitoring all of those things and that made a substantial difference in terms of what we did in Office 2003.

So using the magic of software to drive the very rich feedback loop, I think that's the key direction for our industry in terms of well-designed software and super high quality, still allowing the rich ecosystem we have, where many pieces come together, it's not monolithic but it's drivers from many people, the applications from many people, the hardware from many people, preserving that richness and yet making sure that when it comes to the end user, they're having a great experience. This is the approach that will give us the best of both worlds there.

Well, I mentioned that hardware innovation is one of the positive factors that drive us towards the new wave. That's been true of all the previous waves. Graphics interface, that wouldn't have been practical without the 386 and 486. We needed that advance. The Internet wave, the idea that you could connect across the globe and send information without even monitoring how much of that was going on, that required the unbelievable advances in optic fiber, bringing communication costs down very dramatically, sort of at the same kind of exponential rate we've had with chip improvements through Moore's Law.

In the next years ahead these hardware improvements are moving full speed ahead. Despite the fact the IT industry is economically in a tougher period than at many times in the past, these innovations have not slowed down; whether it's the high-capacity disk that we can take for granted, the move towards more processors, higher clock speed, the move to 64-bit, we're very excited about the work going on here. The Itanium work, bringing 64-bit capability to the X86; both of those are things that we are supporting full bore, and we're seeing great performance come out of those things.

Another enhancement that hasn't been talked about very broadly is the fact that the next generation of processors will build in a new security capability called, kind of obscurely, Next Generation Secure Computing Base, or NGSCB is the acronym for that. What that does is it allows you to still run arbitrary third-party software to be able to make security guarantees, that the decryption keys and some software is running in such a way that that third-party software is isolated from it.

And so when you think about medical records or confidential business information, the idea that computing can preserve the privacy and the rules around those things, we think that's very important and it's been a great collaboration between the software companies and the hardware companies to come up with the standards that will make this available.

We don't just have numeric improvements of speed and memory, we also have computing being used in a qualitatively different way. The wireless networking that has exploded through Wi-Fi, that, whether it's in the home or at work or in places where businesspeople spend time, that's something we'll be able to take for granted.

The fact that the computer turns on quickly and the network is always there, we think that that really changes the way you think about these things.

Broadband penetration is going up every year. In fact, cable and DSL have been on a very fast growth ramp in all the developed countries, some lagging behind, Korea at over 60 percent, sort of leading the way and showing some of the phenomena that develop when you have that kind of penetration.

So the personal computer in less than three years will be a pretty phenomenal device. The graphics capability, some of which we have in today's machines and not exploited by all applications, will be even better. The memory, the speed, none of these things are the constraint. In fact, I think it's simple to say where the constraint is in this era. It's not the microprocessor, like it was when we needed performance for GUI; it's not the cost of networking, like we had to worry about when the Internet came along. Here, it's software, software that is managing itself, software that's reducing the complexity and that's really today's theme, getting the platform to be rich enough so that this all comes together.

Now, as we look forward I think it's instructive to think about the twists and turns we've been through. We've probably learned a lot by the things we've done well and the mistakes, so let's look behind the technology and see what lessons the last decade has for us.

(Video segment.)

BILL GATES: There are a lot of lessons there to guide us as we go forward.

Microsoft talks about this decade as the Digital Decade. What we mean by that is that activities like listening to music, organizing your photos, annotating those, sharing them, buying products, all of these things will be dramatically driven by software in a way that they were not at the start of the decade. When we map this into business productivity we can say that the increase in productivity will be much stronger in this decade even than it was in the last, even though it won't be accompanied by some of that same hype.

Now, part of that is that the expectations of the last decade, some of them required more time. The idea of e-commerce required a new platform. What is that platform? It's the industry standards of Web services and companies like Microsoft with .NET creating tools that make building those applications practical, creating the standards for the exchange of information.

In this decade there's no doubt we'll see every form-factor advance, and the form-factors are very complimentary, from the wrist-sized to the pocket-sized to Tablet-sized to desk-size to the wall-size as well. And so across a large range of activities, whether it's organizing calendars with friends, scheduling business appointments, understanding sales results, filling out what used to be paper forms, searching for information, all of these things will get software involved in a very deep way.

Now, we've had too much complexity, too many different commands, different ways that information has been stored that people have to understand, so in order to achieve this we not only need to solve things like security and applications, but also a lot of unification of the different things that have existed on the PC.

We certainly can think of this as having three characteristics that I'll go through: connected systems, information driven and complete end-to-end experiences.

Connected systems, we can think of lots of different networks, the whole Customer Relationship Management things about a network of customers, social networks that we're seeing through neat software approaches, personal networks, scientific networks connecting up to see data, for example, what has been done using Web services in the whole field of astronomy, where you have all the databases at different sites and you can reason about principles of astronomy and gather information to see if the data is consistent with that.

Connecting those things together so you don't think about the physical locations, so that it's easy to set up and easy to secure, there are some deep capabilities that are required in the platform for these connected systems.

What are the breakthroughs? Well, first and foremost we have the advanced Web services. I hope all of you have been following the progress in this area, and it was very exciting just in the last month to have an event that both Microsoft and IBM created where we showed IBM's WebSphere and Microsoft's Windows .NET connecting up with deep security, transaction capabilities and reliable messaging. Those are the key features that characterize the advanced Web services and those specifications are in a very strong form today. We're soliciting comments, having workshops, even doing interoperability fests and we hope to have those finalized in standards bodies by the end of next year.

The workflow capabilities come in once you can do the connections and exchange the information, tracking the state of things and not just a programmatic level, letting end users come in and device workflow, see the state of these things; that will be part of the platform.

Workflows often transition from a pure software-driven state to a user-driven state. And so making that boundary a simple one is something that we have got to do in the platform

Distributive management: Management software historically has been a whole other set of concepts. It gets layered on top. It has its own way of doing data storage, inspections, self-description. You have to read both manuals, and it's just a world apart.

With Web services we're not going to do that. We're going to use the mainstream architecture to build in a level of management capabilities that goes beyond what traditional management systems did -- including things like policies on how quickly you expect something to execute; including policies on how you deal with certain error conditions, and so that as much automatic activity can take place as possible; understanding what kind of failure might take place, and being able to model those so that it's not just thousands of error messages when, say, the network connection goes down.

These technologies will have to work with systems that are disconnected. You know, you may have seen what we've done with e-mail in the latest round of Exchange and Outlook, where it's cache-mode. That is, we will replicate whenever we can, but it works great offline. We don't have the notion of the mail client being in online mode or offline mode. It's always working in whatever connectivity is there -- we'll go out and get the new information. That sort of architecture needs to be available to all the applications.

Likewise, peer-to-peer networking -- peer-to-peer is very, very important, and it's something that the rich messaging architecture built into the system will have to support. And that's why we'll be able to thinking of computing in a different way, because those connection things won't have to be recreated by every piece of software.

Users want to manage information. We have the information in silos -- mail is separate from the files, is separate from the Web pages. And the information has not been structured. All the operating system knows about files is that they are binary screened. That's it. You know, something like the address book is at the application level, not at the platform level. So if you want to share address book across applications, you can't even do that. The ideas with searching -- the search command is different in every application. So learning how to search mail and navigate mail is different than learning that for files.

When you get attachments sent to you, storing those, understanding the different versions you might be getting -- it's very complex. And so just dealing with information has not been very rich. We don't have standard schemas for the concepts. We have the clipboard, but we haven't gone beyond the clipboard to structure the information, to make replication in searching just a very straightforward thing that you expect out of the system.

So in the next wave we've got to have those rich views, got to have content indexing, got to unify the storm. We have got to have the schemas allow you to classify things so that things even appear to organize without you getting involved.

We see a little bit of this in the Outlook Client, where you have search folders, so that if you want to see all your mail from one person, you just click on that folder. You don't have to drop something in there, because it's essentially a standing query. And so information can be in many locations; it's just a matter of defining the criteria, not having to move it around.

The ability to intermix files and mail and notes into one hierarchy that is organized the way that you want it to be is a very different thing. And this ability to say, "When do you want to be notified?" -- what we call information agent -- that, OK, if something new comes into this folder, that's urgent for me -- you know, "Contact me on my cell phone or interrupt what I'm doing," depending on the context. That again needs to be in the platform. Because if you don't do information agent in the platform, every application is constantly trying to get on top and set up its host and will hurt the user. And there's no framework for making sure that the user's time is what you optimize for -- letting them be in control, not just for mail but for all the different events that take place in the system.

We need to bring this together with full end-to-end experiences. And that means the visualization being richer and more engaging; it means taking greetings and having it be very attractive on the screen, so that the tasks you do on paper shift very substantially towards doing notes on the screen -- even things like managing subscriptions for people or the very rich search and replications that I talked about are key to these experiences.

We will build speech capabilities into the system -- a big advance for that in "Longhorn," in both recognition and synthesis, real-time. You're seeing that become more and more important. We've got now the instant-messaging capabilities. We've got real-time connections add-ons. But this is something every application will use in the next generation. I talked about reading and visualization.

The hardware level is key here, these qualitative changes where desktop displays will be either very large or multi-screen; you know, three 21-inch LCDs, or a single 26-inch LCD will cost only $500 or $600 in three or four years. So we have to think about managing the windows and letting people see a lot more than they can today.

The graphics processor I mentioned will be a lot better there. So we can use all of this for ink, animation, sound processing -- a different way of the system.

Two examples that I like here: a consumer example is managing your memory -- not just your photos, but all of the timeline and schedules and annotations and movies that you make, and making those rich and easy to navigate. That's something that people are interested in, and it unifies a lot of things that have been separate. Until we had a lot of this database technology, we couldn't unify those things. The photo application stored things its way, the sound application its way, and they were not brought together.

Another, thinking about meetings in the future, how you prepare for them, schedule them, the meeting itself with people not local, using things like Live Meeting to connect up and share. And then after the meeting, having that transcript that's made automatically -- automatic direction, where you take the audio signal and know which visual view would be most appropriate, and therefore let people watch the meeting later, but watch it faster than in real time, and just watch the parts that they're interested in. So each of these is a pretty dramatic example that drives the platform and can make a very big difference.

So it's going to come together in "Longhorn." This is our next major release. Jim will make sure -- it's very clear we're at the beginning of this process. You know, we're opening it up to you, showing you what we're thinking, because we need your feedback. We need your involvement to get this right.

This is going to be a very big release -- the biggest release of this decade, the biggest since Windows 95. We're tackling three different areas: the fundamentals -- that means the security, the auto-installation; applications not interfering with each other. There's a lot in the fundamental area. Jim has very deep passion for this, and he'll be going through all the different things that we've been able to do there.

It's an advance for customers, being able to connect up, being able to have your information appear on all your different devices; having that information structured without you doing a lot of work; having less commands despite the new richness that's there, and using capabilities around the agent to take and put you in control, so that understanding your privacy and what mail is coming into you. You feel like you have a few simple things you do that put you back in the driver's seat there, so you have confidence and control.

For developers, we want to take the things that people have had to duplicate and bring those into the platform so you can focus on other capabilities. So faster developments are driven by the major new sub-systems.

Here's the simple diagram of "Longhorn." You'll see this many times over the course of the next few days. The fundamentals, of course, are down in the base. Avalon is the presentation system. This is a timely advance. GDI, user, those are cool things, but those were really architected with memory limitations and graphics limitations from a long time ago. We're even seeing some applications go around and use direct decks, like Movie Maker does, to try to get a new level of visual capability. But it's time we brought that all into the mainstream -- the clear-type reading capabilities that a few applications are using, and that you know some people don't even know are there to turn on even when they're using that LCD display. Well, we can go a lot further by designing it in.

So it's a built from the bottom up, built around XML, new display system. It's organized around a compositing approach, very rich, very extensible.

"WinFS" -- this is unified storage. Some of you here have heard me talk about unified storage for more than a decade. The idea of taking the XML flexibility, database technology, getting it into the file system: that's been a Holy Grail for me for quite some time. And here it is. Thank goodness we have got the powerful systems to be able to do this thing. Thank goodness we have the evolution around XML and user interface capabilities, so that this can all come together.

And then, finally, the piece that takes a lot of things that were extra cost options -- queuing software, transaction software, pub sub software -- and takes this new messaging approach and makes it built into the platform. So connecting up between applications, whether it's within the system or across the entire globe, that is very straightforward.

We want to give you a quick glimpse of some of these things and how they come together, and so I want to invite the person who is really driving the user interface to come together to give you a look. So let me ask Hillel Cooperman to come up and give you a sense of what Longhorn is all about. Good morning, Hillel.

HILLEL COOPERMAN: Good morning. Thanks, Bill. How's everybody doing? OK? Well, maybe we can get you a little more excited. Do you want to see "Longhorn?" All right, let's take a look. Let's bring it up on the screen here. Now, we are going to start off with CTRL-ALT-DEL, because it wouldn't be Windows without CTRL-ALT-DEL, right? Clapping for CTRL-ALT-DEL. That's all right, you can clap for it. Save your claps -- I've got better stuff.

All right, see here, we are going to log in, and when I log in I want to show you the brand-new "Longhorn" desktop. Here it is. Let's open up a window. See how that comes in?

A couple of things going on here. First, there's a new look. And, as excited as we are about that, and we hope you think it's exciting and beautiful and professional, but it's still early. The most exciting part is that making a new look is relatively easy. Building this deep into the platform as part of the platform that you get to take advantage of, that's tough, and that's what we have been working on. So, if you notice, things like the transparency that we have here on the Windows -- watch as I move this kind of under this guy on the side -- you can see it in the background there. Let me open up a couple more windows. Watch how these actually animate onto the screen. And this is using things that are part of "Avalon," just like Bill talked about -- including things like pixel shaders, the desktop composition -- all this advanced graphics functionality that to date has been typically the domain of game developers, now available to actually render you either on the desktop and, of course, in your applications.

And just in case anyone is thinking that maybe this is some kind of prototype or something, let's run a classic application. Anyone remember VisiCalc? There it is. It's 20 years' commitment to compatibility. And now we are going to see if we have 20 years' commitment to usability, because I am going to figure out how to quit this thing -- forward-slash, S, Q, Y -- oh, yeah, there we go.

All right, so let's take a quick look at the desktop. And before we move on to some of the big pillars that Bill talked about, I want to talk to you guys about that guy on the side there. It looks pretty prominent, so we should address it. Right now we're calling it the Sidebar. We'll figure out what the final name is at some point. But what's interesting about this is a couple of things. First, it actually built in these common parts that show information, notification, services, that a user might really be interested in seeing when they're working on their main application, without popping up a window that covers it. For example, the time or their buddy list or a slide show, which, of course, you can add and remove these tiles here -- or even an RSS-feed built right into the sidebar.

And you want to hear blogging or about to blog when they get -- who is going to be the first person after the keynote to go and post on their blog. Scobel, OK. Well, we'll see. It's going to be a race. But the best part about this is not that we have this functionality built into Windows. The best part, like everything I'm going to show you today, is that this is part of the platform. This is part of the SDK that you guys are going to get, you guys can write to it, and we think you can do great, great things with this.

All right, so let's dive into some of the things Bill talked about. Let me open up this documents window. Now, in some ways this is a pretty straightforward screen. This is essentially the evolution of my document, but a couple of things are different. First of all, we are showing almost 1,100 items in this view, which, frankly, given today's experience, it would be a little not useful. And, in fact, these items are not sitting in one folder. They're located across the system. And this view is actually a dynamic view that is generated for you right in the system, and of course available as part of the platform.

So let's do a simple thing that you think would be simple today, but "WinFS" is going to provide built-in search facilities. So I have 1,100 items. I want to find all the items that have something to do with "Longhorn." So as I type I want you to watch the number right here, 1095, go down to 30, and see how fast that happens. By the time I'm done typing, we're down from 1,110 to 30 items right there in the system.

Now, built-in search capabilities -- this is something you're going to expect. But let's talk about the kind of self-organization that Bill talked about in "WinFS." For example, let's say we want to take these 1,100 items and organize them by a property, a property that is built into the schema. So right here we have author. We click on "author," and we could actually filter down the 1,100 based on who the author is, or we can do this new thing called stack. And when I click on "stack," it actually draws a new view that shows all these items in these stacks by who wrote them. And in fact, if you look carefully at the stacks, they have different heights, depending on how many items are represented in them. And because they are not physical locations, one item can show up in more than one stack. And these are folders that when created this dynamic view being built for me on the fly based on the rich structured meta data that is sitting in "WinFS" on these items. So let's double-click on "Bill."

Now, the properties that are built into the schema are well and good. But of course you are going to want to add your own. And it's not just users and IT professionals, but of course developers that are going to go extend these schema in any way they want. So let's actually add a property right now. Let's add project to our view. I click right here on "project" and I can stack by project. And in fact I can go down here and see here's all the stacks, and these five items down here aren't attached to any projects. So you might think, based on how it works today, the painting metadata on an item in the file system is difficult -- right-click and go into the tabs and it's kind of a cumbersome process. I'm going to take this document right here -- and anyone who loves their Tablet will notice that we have ink file names right in the shell view. I'm going to take this, each collaborating file name, and I'm going to take this and I'm going to -- painting metadata on it, for example the Windows "Longhorn" project -- is as simple as drag and drop. And in fact I didn't actually put it in a folder. I just painted metadata on it. If I double-click on Windows "Longhorn", sure enough that document is going to show up in our query results right here. Here it is.

All right, one more thing. You might say, "Well, I understand that these views are generated dynamically. I understand this is all based on this structured metadata that Bill was talking about, but I could kind of approximate this with folders today. I could make a bunch of folders for authors, and then in them have project folders." I'll tell you something you couldn't do. You couldn't do it, have that exist, and do the reverse; for example, be able to navigate first author, then project or first project then author. So let's actually take a look. And if you notice, by the way, notice where my cursor is, as I've gone through the system it's actually built the query for me right in the user interface. So let's go back up. The document -- and instead of documents-Bill Gates-Windows "Longhorn" -- let's go add "project" to this view again. Let's stack by project, scroll down and go to Windows "Longhorn" -- all getting dynamically generated by "WinFS," stack by author, double-click on Bill, and there's the same 50 documents that we showed in the original query coming at us from a different direction.

And the best part about this is not just that you can do this in the system, but all this is available to you as developers as part of the platform whether you want to use the com controls or talk directly to WinFS, and render any way you want.

All right, so there are a lot of documents in the world but having structured information in your system is not just about documents. For example, what about people? Bill talked about actually having all the different ways that people get out of sync today. You store people in cell phones, people in groups in your buddy lists, in your address book, in your corporate directory. Right now we're going to represent this non-file item right here, again another one of these views, this is people and groups, again viewed in the same way that we view documents.

This first thing right here is a group. All these are people. I can right-click on Bill, for example, and, in fact, there's a bunch of things I can do with him here. So I could add him to my side bar so he would end up right here on my buddy list. Bill and I are often having buddy list conversations late into the night.

And I could do something called Show Communication History. Today if I want to see all the faxes, all the files that Bill shared with me, all the notifications or e-mails, I have to go to several different programs to go see all that stuff. Right here I can actually generate this view dynamically right in the system coming out of WinFS because all these items, faxes, RTC conversations, e-mails documents setup are all part of the basic schema and we can generate this view on the fly, and again this is part of what is available to you in the platform.

So I keep talking about the platform but I keep showing you how we're using it ourselves. So we thought about let's show you an application using this stuff. And instead of starting off with an application that's built top to bottom, on top of "Longhorn" we said we thought we'd start with something that's already a big investment in Win 32. Anyone here have any Win 32 investments? Just a couple.

And, as you already know from what Bill said, if you've already been investing in .NET on XP, you're well on your way to a bunch of this stuff, but we really want to make sure that you can leverage the most out of your existing investment.

So, here we are in this Win 32 application. We took it, it's an OE built-in Windows mail app. And again, notice as I type I get this little choice here to find more names. What this brings up is a common file dialogue, but for people. It's not files after all; they're people sitting in WinFS and it lets me actually look at this entire list in this big corporation of all the people I can choose from or even search my corporate directory. I think we have the corporate directory from Microsoft here, but I can search, let me search for Chris. It's very convenient that there's only one Chris at Microsoft. I don't know how we made that happen. All right.

And now notice, by the way, that's just bringing up the dialogue, I can embed that right in my application. As I start typing I get an "Avalon" common control embedded right in my application that let's me pick from a variety of people to actually go and address my mail.

So, we can go, send the body of text: "No need to write your app to take --" let's see if I can get through this without a typo. Oh yeah! And, hit Send. There you go. Existing application, leveraging the platform, right with your existing investment and already getting the benefit right out of the box.

All right. So. If you've been paying close attention you may have noticed up on my Sidebar I have a buddy list and this person is offline, these people are online, but here it says Craig is nearby. And, in fact, if any of you've been watching up on the stage Craig is in-fact nearby. Hey, Craig.

CRAIG BEILINSON: Hey, I am nearby. More importantly though, my laptop is nearby.

HILLEL COOPERMAN: Hey Craig, how's it going?

CRAIG BEILINSON: Fabulous, how are you?

HILLEL COOPERMAN: Great.

CRAIG BEILINSON: Hey, good demo so far, but I thought really before the PDC gets kicked off, I thought, I've been taking some notes, I can give you some feedback on your presentation.

HILLEL COOPERMAN: Actually, now is not a good time.

CRAIG BEILINSON: We're among friends, aren't we. You know, the nicest thing about this is how natural and unscripted it sounds. Feels very natural to talk just like this.

HILLEL COOPERMAN: All right. So, Craig wants to do a pretty simple thing that everyone can relate to. He wants to share some information with me. He has a peer-to-peer connection with me, this persistent peer-to-peer connection that's again part of the platform in the communication stack and he wants to share something. But he doesn't just want to share it, he wants to do a little bit of show and tell.

So, in fact, what Craig has done, he's done a couple of things already. One, he's made it possible for me to see him on our network right here because he's nearby. So, not everyone can do that, he's allowed that to be possible. And he's already started publishing the presentation on our network, so he's projecting his screen onto the network. If there were more folks with this type of machine right here, you'd all be able to see it projected. It's kind of like a broadcast.

So, I could either click on Craig or I could go right here in the Start Menu and get a list of all the available presentations that are being broadcast. So let's view the presentation, here's Craig. Now what's going to come up on my screen is actually a live view of what's on Craig's machine. You can see his Start Menu, Task Bar, et cetera, and he can actually move around as we go. This is not a static image. This is a live broadcast of what Craig is doing. Right now it's one-to-one, but it could be one-to-many right off the "Longhorn" PC.

Now, as cool as that may be, let's actually resize that. You may think -- no there is no bathroom breaks here, I'm sorry. You may think that actually resizing would mean all sorts of unmanageable scrollbars and having to go and move around to try and see everything at once. In fact, I'm just going to hit Restore and watch what happens to the window automatically because of our "Avalon" presentation services. Automatic resize on the fly; even as I resize it, it moves around and Craig is doing it live right on my desktop.

Alright, so let's move this down here. So in some ways we've done the hard part. Craig has done this personal TV broadcast essentially to my machine. The easy part, you would think, would be just sharing a file, not broadcasting but just simple file sharing over this persistent peer-to-peer relationship that we have. In fact, that frankly is pretty hard these days too. So, Craig is now going to open up one of these dynamic views that I showed you before like the communications history, like documents, like contacts of all the files that I've shared with him.

Here they are. Now I want you to watch this space closely. I'm now going to move over to my desktop, I'm going to right click on this file, this image, and I'm going to hit Share with Craig and watch. When I click, what happens over on Craig's machine: 3,2,1, boom, there it is. Instantly replicated over to Craig's machine. Even if he were to disconnect, he has access to it. Craig, double-click, let's make sure it's the same one. There it is.

All right, so, if I check our clock here, we are running out of time so I'm going to move along. Thank you, Craig, great job.

OK, so again. I've talked to you about the fact that we're building a lot of it that on top of this technology we're building a ton of the Windows experience. But the fact is we want to show you how an application that's built top to bottom might look on top of the pillars that Bill talked about.

So, for example, let's open up this Web page here. This is a common situation. You have an application whether it's an internal application or a commercial application that you want to deploy to your customer. Today deployment is hard. It's expensive to test, you have to make trade-offs between building a Web application or a client application. It leads to all sorts of different switches and results when it comes to deploying your app.

I'm going to click right here on the Web site from this developer and what is going to happen right now is the app is getting installed on my machine as we speak. I can tell you of no worse fear for a demoer than installing a demo in front of a big audience.

So, there's no big dialogue. This is essentially just the delay while we go and make sure the app is going to work. We do all the security stuff, all the bits come down off the wire and we get this brand new Avalon-based application launched right on our screen, one click.

All the things that I showed you before are also available in here. The search facility built into WinFS, I just go type my string, bit goes, sure enough there is my item.

Now, what are these things? We talked to you before about viewing items that are in WinFS right in the shell and how that is available as part of the platform. Well, here's a bunch of items in WinFS that are shown in this application.

Furthermore, we talked about extending the schema and how a developer could do that. So, we have arguments and evidence and precedents and people, all schema extensions that this developer did in this sample application to the bases scheme that comes with Windows.

We talked about creating relationships between items in WinFS. Notice as I hover over each of these items, the items that show up in yellow are actual relationships. And so if I were to click, for example, right on this person, watch. All the items related to it show up in this custom "Avalon" view.

I want to show that you one more time because I want to show you how seamless it is. Remember, yes, "Avalon" provides built-in common controls that you can use to get up and running fast and they're very flexible, very powerful, but at the same time you can always talk to "Avalon" lower in the stack and decide you want to go do your own custom view. And the transition between these is just seamless. Click, animate, there's the custom view.

Now, "Avalon" is not just about showing you why, it's not just about graphics, it's about media as well. So here as part of evidence we have a video, let's click on that video and I want you to see how this developer and their sample app has tried to show that integrated into the application itself. This is video of the actual accident. How convenient that we have professional camera crews filming the accident from multiple angles. I don't know how that happened.

But, again, look at that again. I mean, right in the application they decided they wanted a circle, they decided what to show, they decided to face it back out into the UI, all built on the platform that we're providing in Longhorn.

All right. So let me do something else. Now I talked a lot about Win FS, talked a lot about "Avalon." I want to talk a little bit, because we don't have too much time, about Indigo. When you think about Indigo you should think about Web services. It's really on that path that Bill talked about in terms of making all those connections between all the information at work and at home.

So, in this application, they've exposed a Web service Lexus/Nexus. What happened? Lexus/Nexus decided that they wanted to expose their service as a Web service. This ISV decided to consume that Web service. We showed you before searching across the local machine, across the corporate network and now let's add searching across this Web service. So I click here, hit Search. Sure enough, I get results from all three places. Go to Lexus/Nexus. Here's my document and remember, secure authentication, the transactions have all happened in the background. And in order to consume this data from this Web service we don't have to go to the Lexus/Nexus application. Lexus/Nexus information is showing right in this developer's app courtesy of Indigo.

And, if I want to bring this information right into my application and my network, or this document rather, I can click on it, drag and then drop it and go create a relationship on the fly straight from the Web services. Let's drop it on Jeff and then notice as I hover over Jeff, here's the document, when I hover over the document, there's the relationship with Jeff. I click on Jeff. Let's click on Jeff. Here it is.

Now, I talked about "Avalon" being this great platform for showing media and UI and great graphics. But you know what? Text and layout and integrating that into the flow is also very, very critical. So, I'm going to click on this "Avalon" formatted document, and you will notice it's courtesy of the Lexus/Nexus Court Link Web service. And, in fact, this is all rendered via "Avalon". If I were to, for example, hover over the scroll bar here at the bottom, notice I get this rich thumbnail as a third page. Click on it. Navigate. Click on it. Navigate.

Now, let's open another one of these. Now, here's another example with a document with text and video integrated. I can go do that same little thumbnail preview on the scroll bar. I click, navigate to page three and here's the big question. If I hover over the area of the scroll bar for the second page, will I get live video in the thumbnail? Yes, yes, let's do it. Click, there it is, live video, right there you can see it. Let me click and go straight to the page of the document itself.

All right. That's all the time I have but if there's three things you take away, one, we are very excited to show you this. There's several thousand developers up in Redmond watching us live right now, thrilled that we finally get to show you some of our early work and very excited to hear to your feedback.

Second, we're using this ourselves. We're building the next generation of Windows on top of this great technology.

And third, we're thrilled to see what you're going to do with it. There's a lot more great stuff coming up. Thank you, very much.

BILL GATES: Well, it's fun to see "Longhorn" coming together.

We have three different waves of software over the years ahead. We have the software that's out now and this year we had more new product introductions than in any year in Microsoft's history. Just what we call the Office System that was introduced in New York last week had a lot of different pieces driving XML into the Office platform, letting document-sharing work on the server with SharePoint in new ways, bringing real time in, so a lot of neat things that we can take advantage of today, including real focus on the fundamentals for even the existing software packages.

You'll hear a lot tomorrow about the wave that includes the next generation of SQL Server and Visual Studio, and then, of course, most of what this event is about is "Longhorn." But targeting your work against each of those waves we think is pretty important, so you don't miss any of the opportunities.

We're already seeing some neat things happening in the marketplace. PC growth is back at a reasonably healthy level this year. The kind of applications we're seeing on the smaller devices, this is a Motorola phone called an MPX 200, of course, it's got .NET built in, neat new things, these are really just coming into the marketplace but the popularity has been pretty incredible. Motorola is a new partner for us, just announced. Also Samsung has this, which is their I600, which is a very rich media focused experience.

So in the mobile scenario the second generation of tablets coming along, 64-bit servers, connection out to Xbox with some of the things we're doing there; all of these opportunities are starting to unfold but it's going to take a major new platform leap to be able to have the full capabilities that these things demand.

So a quick summary, first the fundamentals: We've got some online things that talk about applications and security applications and working with software updating, which for us is our SUS and SMS products, management packs around our MOM capability, all of those things fitting into that fundamentals area. Designing around Web services, making sure you've got that as your extensibility architecture, your connection architecture, you're seeing us drive forward with that. Using managed code for any new things you do and yet we allow managed code to work with existing code. Exploiting the client, delivering data in the form of XML to the client and then having local rich rendering while still being able to have mapping to HTML for reach, that's something we're making very simple. Eric Rudder tomorrow will really go through how that approach is becoming mainstream.

The final point is we want your involvement in telling us what we've got right with Longhorn, what we've got wrong with Longhorn. We've got years of work here and it's going to be shaped by your involvement in the community activities. And we've done a lot of new things, including the ways we've refined this event, getting our developers online, to really make sure that the community component drives "Longhorn" to be exactly what it should be.

So I'm excited about the opportunity, thrilled to have you all here kicking off the "Longhorn" generation.

Thank you.

Source: http://www.microsoft.com/billgates/speeches/2003/10-27PDC2003.asp