ANNOUNCER: Ladies and gentlemen, please welcome President, Server and Tools Business for Microsoft, Bob Muglia. (Applause.)

BOB MUGLIA: Well, good morning. There is no question that the world runs on software. Just look around you. Look at everything. Look at all the devices we use, all of the systems we interact with, the car, the airplanes: every part of our lives today are powered with software. This has all happened in recent memory; certainly during my career this has happened. It wasn’t true when I was a kid growing up. And so software has risen to an importance in the lives of people, the way we do business, to compare to almost nothing else on the planet.

And of course at the heart of software are developers. Developers are the ones who make it all happen; they’re the ones that pull it together. They’re the ones whose shoulders upon which all of this ultimately rests. And so I view it as incumbent certainly on Microsoft, our partners, and all of us to work together to understand how we can make the development more effective, to solve the problems that exist today, to enable businesses to build solutions faster than ever before, to be able to connect to people in ways that could never be connected before.

And maybe most importantly, to enable a better life for the billions of people around the world whose lives still do not run on software. It will be software and the solutions upon which it’s built that the world will come together and the problems of tomorrow will be solved. So, developers are really very much at the center of things.

But like everyone, developers have many challenges. There’s a lot of opportunity for us all to improve the way developers work and to make them even more effective than they are today. Developers face constant interruptions. How can we help them stay focused? The technology that we work with, that is making the world run on software, is moving forward at a speed that is unprecedented. I certainly never remember anything in my history like what we see today in terms of the level of advancement.

And, of course, the complexity of the solutions that are being built can no longer in general be built with just a few people. Sometimes things can start that way, but ultimately, it’s teams of people that work together, together with the needs of the organization that provide the ultimate solution. So, whatever we can do to make people more effective, working together in teams.

That’s all very important and that’s what we’re taking your input on, that’s what you’re telling us you need. These are the problems that you’re telling Microsoft that you need to see solved, and how can we keep developers focused and enable them to be as productive as possible, even in a world where they are facing constant interruptions, so when they are interrupted, they can quickly resolve that and get back to solving their core problems. How can we help keep developers current and make it easy as possible? As someone said, we need to make it so that only the code — the code that only you can write is the code that you write. How can we keep developers current and have you understand what the technology can do and how to most expeditiously solve your problems?

And then very importantly, in the team, how can we make the overall team work as effectively as possible together? Not just developers working together, but developers working through the entire life cycle of the project.

Those are some of the challenges that developers face, and some of the opportunities associated with solving those problems. And we’ve been hearing those from you. We’ve been listening. You’ve given us a lot of feedback. We’ve been trying to incorporate that feedback over the last two years.

And so today, I am very pleased to announce the release of Visual Studio 2010. (Applause.) Yeah.

Now, you know, today is a celebration. We get to talk about all of the great things that are here now with Visual Studio 2010 and .NET 4.0 We get to focus on the things that we can all do together moving forward, and how you can take advantage of it.

There aren’t a lot of surprises in terms of what Visual Studio 2010 does. It does what you asked us to do, and most of you have been working with it in the past month and even longer because we’ve had it in test in our CTP test programs for quite some time. But it’s available now. It’s available for purchase, it’s available as a part of MSDN, and it’s now production-ready and ready for these new solutions to be built. So, it is, indeed, a day and a week to celebrate, and it does open up all of this opportunity for the new solutions.

So coming in and focusing on this, one of the key things that enables Visual Studio and the overall work that you do to be successful is the work that the ecosystem all-up does, all of the partners that are involved in helping to make the developer environment of Visual Studio real and allowing you to solve these problems.

And one of the challenges in the past has been that sometimes it’s taken a while for partners to have all of their solutions ready to participate in those solutions. We’re pleased that today over 50 partners have announced the availability of their products, production ready, available for purchase, available for use right now with Visual Studio, and there’s a lot of new things in Visual Studio that enable partners to make you, the developer, even more productive than you’ve ever been before.

So it takes a village to solve this, and it is the connected ecosystem of our partners that make it happen, and we’re really pleased. I want to really thank — I mean, give a hand to our partners. (Applause.) That have come through, that have worked hard to get their solutions ready so that you can go off and solve the problems that you want to solve. So, it’s very exciting.

So now I want to focus in on what you can do with Visual Studio, and that’s really what the rest of this talk is all about. So, from this point forward, pretty much, we’re going to talk about all of the things, the different types of solutions that can be enabled with Visual Studio 2010, with our partners, and with the next generation of products, the current generation of platforms that Microsoft has to offer.

And so the first thing I’d like to focus in on is the breadth of new features and capabilities in Visual Studio to make the developer more productive, to keep the developer focused on solving the problem that they have in front of them, to write the code, to get the job done. And this is a release of Visual Studio that covers an awful lot of ground. There’s a lot of surface area, so there’s no way in this keynote that we can come even close to touching upon all of the features. But we’ve made a very large investment in improving the developer experience with Visual Studio 2010 and we think that will very directly translate into making developers much more effective, much more able to quickly write the code that they need to write.

And so with that, what I’d like to do is invite Sam Gazitt up to show us some of the new features in Visual Studio 2010 and some of the things that this can do to make you much more productive, Sam, good morning. (Applause.)

SAM GAZITT: Good morning. Thank you, Bob.

BOB MUGLIA: Thanks.

SAM GAZITT: So, Bob, you spoke about some of the distractions that developers deal with every day. And we’ve all been there, cranking out code on the verge of breaking through, when something breaks our concentration, forces us to change concepts, and oftentimes, leave the IDE. In this demonstration, I’ll show how we can use Visual Studio 2010 to stay in the zone.

Let’s get started. As a developer here at Blue Yonder Airlines, I’ve been asked to go and update our public-facing Web site. Now, we’ve already started cleaning up the project here, and I’ve got it open in VS 2010. Notice that I’m taking advantage of the split-view designer to work between source and design. But I also want to work on the associated code file, and I can certainly open that up here in Visual Studio 2010. But notice that my document roll has gotten cluttered. I spend a lot of time going back and forth here between the various parts of my Web site, and really what I’d like to do is take advantage of the multiple monitor support in Visual Studio 2010 to see the entirety of my Web site at the same time.

So I can snap the code file out of the document well, outside the IDE, and onto a separate monitor. That’s pretty cool.

BOB MUGLIA: Yes. (Applause.) Multi-monitor. We’ve been waiting a long time to enable developers to really use all the screen real estate, and no one needs it more than a developer who is working on so many detailed things simultaneously.

SAM GAZITT: That’s exactly right, Bob. I can see all the parts of my Web site. I can see the Web.config, I can see the code, I can see the source.

And so let’s jump over here to take a look at my code file now. Let’s take a look here on the left. Now, I can start doing some clean-up work. I can scroll down here, and immediately I can see that we need to make some of these private variables public. Well, I can certainly make the change in all 11 lines of code, but instead, I’m going to take advantage of a new feature in Visual Studio 2010 called Box Selection. And as I type here, Visual Studio is going to update all 11 lines at the same time. So, I can very quickly turn private variables into public variables, and that’s going to save me some repetitive typing. (Applause.)

And as it turns out in Visual Basic 2010, it’s as easy to make a property as it is a field or a variable. So, I can do a six-character box selection and turn that into a property. That’s pretty cool.

OK, scrolling down a bit, you’ll notice that my code file is actually quite long and quite done. What I’d like to do is leverage the Windows Presentation Foundation base editor in VS 2010 to get a bird’s-eye view of my code file. So, let me zoom out here and see the entirety of my file. Now I know exactly which parts I need to refactor, and I can zoom in directly on the areas that are good candidates for refactoring.

BOB MUGLIA: One of the things that we’re really excited about, we put a big investment into the new code editor as a part of Visual Studio 2010, and it has a whole set of new capabilities, such as the one Sam just showed you, but what’s maybe more important is it has a whole broad set of extensibility points, which allow you or our partners to provide all sorts of new features that we’ve never even dreamed of.

SAM GAZITT: That’s right. So, I can certainly take advantage of the built-in support for refactoring here inside of VS, but as you mentioned, I’ve got a favorite partner extension that I’ve been working with for a long time now, and I’d like to take advantage of that directly inside of the IDE. And, Bob, you mentioned that a lot of our partner extensions have 2010-compatible versions, starting today. But I don’t want to go and search for that online; instead, I’m going to take advantage of a new window here in Visual Studio called the Extension Manager, to go and manage my extensions, but more importantly, search for new extensions online.

So here I can type in “refactor,” for example, and I get some great partner extensions surfaced here in the IDE. In fact, Visual Studio is searching the 1500-plus extensions in the VS gallery with over 400 free extensions. That’s a great experience.

Okay, so I’ve got my IDE ready to go, I’ve been making some progress, I’ve been cranking out some code, and boom, a co-worker pops in and asks me to help on a new feature. Now, I certainly want to be a good team player, but I want to get this done as quickly as possible. So, let’s take a look at the Web site and see what we have to work on here.

So I have Blue Yonder’s public-facing Web site here. And I go to the “about” page. And it looks like my teammate’s asked me to help him improve the image rendering experience here. We can browse directly to the images, but we’d like to deliver an AJAX-enabled experience that enables the user never to leave the page.

Now, like I said, I want to get this done as quickly as possible, so I’m going to take advantage of built-in support in Visual Studio through the jQuery library. Let’s go back and add a bit of code.

OK, so when we scroll down here, rather than typing out the script tag manually, I’m going to take advantage of built-in support in Visual Studio for HTML snippets to go and quickly add a script tag here. That’s going to save me some typing. Now I’m going to drag and drop some code that I have in the toolbox here to go and initialize the box. This is community-based functionality in the jQuery framework that I’m taking advantage of here from Visual Studio. And what’s more, I get some great Intellisense support here.

Visual Studio is going to surface documentation for me so I never have to leave the IDE; I’ve got a great productive experience.

BOB MUGLIA: So Visual Studio does a great job of JavaScript Intellisense, and that works certainly with jQuery, which is an organization, an open-source organization that we work very closely with, but it also works with other JavaScript libraries that you might want to use.

We’ve also made a very broad set of enhancements to MVC as a part of .NET 4.0, things like a simplified way of doing client-side and server-side validation, a broad set of new features that are in .NET 4.0, and a chance for you to learn more about it this week.

SAM GAZITT: So let’s take a look at our final Web site here. All right, going to our “about” page, you’ll notice now that when I click on an image, it renders nicely in a great experience. This enables our end user to never have to navigate away from the page, and it really improves the interaction with the Web site. And best of all, I haven’t had to write a lot of handwritten, client-side code. I was able to take advantage of pre-existing community functionality inside of jQuery.

BOB MUGLIA: And Visual Studio made it easy.

SAM GAZITT: And Visual Studio made it easy. So, to sum up, I started off by taking advantage of multiple monitor support to go minimize context-switching. I then used productivity-enhancing features to eliminate repetitive keystrokes, and I’ve answered a distracting request by taking advantage of pre-built functionality in VS. All in all, Bob, I’m safe to say that I was able to use VS 2010 to stay in the zone. Thanks, Bob.

BOB MUGLIA: Great. Thanks, Sam. (Applause.) Sam will be back in a minute.

Sam talked about distractions, and one of his developer co-workers giving the distractions. I always thought those distractions all came from management. And I know that I’m the source of quite a few of them for my team, but it is the reality of things, that the requirements change and the need to continually adjust things, and anything we can do to focus on helping the developer to stay more productive is just really very important.

So getting current. Having developers understand and keep up with the incredible pace of technology, and frankly, the opportunity to solve problems because of the things that technology brings. Visual Studio is very much focused on providing developers with the most productive platform — productive development tools on the planet, and those work hand in hand with the Microsoft platforms, which are focused on providing the best set of overall solutions that you can find on the planet.

So whether it’s Windows with Windows 7 and the new work that happens there, the Windows Phone, the upcoming Windows Phone 7. Silverlight; we’ll hear a lot more about Silverlight this week. Scott is doing a keynote tomorrow morning to talk about all of the things within Silverlight 4.0 and what can be done with that, tremendous opportunity.

Or whether it’s some of these other products, some of the server products. Starting with Windows Server. Windows Server is the most popular server on the planet by any account. It’s about 75 percent of all servers, all X86 servers, and X86 servers are now clearly driving the industry forward. There’s no question that the future lies in industry-standard, X86 servers, and Windows Server is, by far, the most popular operating system for that. And part of the reason it’s popular, one of the driving things is the kinds of applications that can be built on top of it. Whether it’s things that Microsoft has built like Exchange or SharePoint, things that our partners have built, the many thousands and thousands of applications that have been built on top of this platform, or the things that are custom-built within organizations based on .NET, using Visual Studio, there’s an incredible opportunity to change the face of business and organizations by utilizing the technology within Windows Server.

Things like SQL Server. SQL Server is an incredible database. It has covered so much ground. It is so popular and it has so many capabilities. We’re on the cusp of a major new release of SQL Server that will change the frontier of the way business intelligence is done, and opens up some very strong developer opportunities, opportunities to take advantage and build new data-centric solutions.

A feature inside SQL Server 2008 R2, which will be available, as we say, within a short period of time, within weeks, is something called DAX. It’s a configuration, it’s a model-based configuration for a database, enabling you to take an instance of a database and have it defined and snapped as a configured model, and then applied to another SQL Server or to Windows Azure, SQL Azure in the not-too-distant future. And so those sorts of capabilities are going to enable developers to continue to expand and simplify the job of building business applications.

And then there’s the cloud. I’ll talk a little bit more about the cloud later this morning, but we see phenomenal opportunity in that environment. So, the landscape is changing very rapidly, the opportunity is opening up through that, changing very rapidly.

One of the key ones, of course, is the Windows platform itself. There are over a billion Windows clients in the world today. Think about that, any number. It’s by far the largest available, consistent platform in the world; nothing even comes close to the surface area that’s covered by Windows. And Windows 7 has been the most popular release of Windows that we’ve ever shipped, the fastest-growing, the fastest time in terms of adoption release of Windows ever.

That’s been true initially in the consumer market with incredible excitement around the holiday season for people buying new PCs. We saw PC sales just skyrocket after Windows 7 was released. And now we look inside business, every customer I talk to, and I talk to a lot of customers, every business customer I talk to is building a plan to deploy Windows 7 within their organization.

Now, some will do it very quickly and get it done this year, some will take longer, but it is almost universal that everyone is doing this. So, Windows 7 is a bedrock of future business productivity. And there are a lot of great things in Windows 7 for developers to take advantage of. Obviously, the entire Windows environment, everything Windows has provided, .NET is there: new features such as multi-touch and the ability to build things with the Ribbon, JumpLists, a broad set of new capabilities for developers to build on top of and, of course, the overall breadth of the Microsoft platform.

What I’d like to do now is invite Sam to come back up and show us some of the things that you can do with Visual Studio 2010 and Windows 7 to build native C++ applications. Sam, come back up.

SAM GAZITT: Good to be back. OK, Bob, you spoke about some of the great new features in Windows 7 and how developers can take advantage of these features in their own applications. In this demonstration, I’d like to walk through taking an existing application and enhancing it to write up on Windows 7, and deliver a great end user experience.

So let’s get started here. First thing I’ll do is show an existing app. We’ve got that here. This is a simple photo view application. Notice that I’ve got the classic MSD-style toolbar here, and I can page through images using my keyboard.

BOB MUGLIA: It looks so classic these days, doesn’t it.

SAM GAZITT: This is a functional application.

BOB MUGLIA: That is an appropriate word; “legacy” is another word.

SAM GAZITT: But we’re going to enhance this and take advantage of the new capabilities. There’s certainly room for improvement because we’re running on Windows 7 on a multi-touch-capable machine.

So let’s open the application in Visual Studio and take a look. Now, the first thing that I’d like to do is add animation support to this application. Now, I happen to vaguely remember the name of the function that I defined the movement for the images. So, I’m going to take advantage of a new feature called “navigate to” to enable me to go search for the symbols in my project. So, here as I type “set” I get some great search results that help me find what I’m looking for. Ah, set parameters, and I can jump directly into the code. Great.

So here’s the method that I need to replace with some existing code that I have here in my toolbox. And this code takes advantage of the Windows animation API. This is a new API for native developers to go and animate their applications.

Cool. Got that done. Now, before I preview the application, I’d like to make an additional enhancement. I’d like to modernize the navigation in my application. Now, we saw the old MSD-style toolbar. Let’s take advantage of a new navigation paradigm. Let’s go add the Ribbon.

So I’ve got some resources here in my project. I have the Ribbon resource. And when I open up the Ribbon resource, Visual Studio will load up a native Ribbon designer. That’s pretty cool. I get a great WYSIWYG experience and I can drag and drop control. And, in fact, I can add a button here to enable my end users to select a different photo.

So let me go set some properties here in the property grid. I’ll call this Select Folder. Great. I’m going to set the image ID here, I’ll give it a nice image, and then let me go and set the ID. Just Select Folder. Great. Now that I’ve got that defined, I’ve got my ribbon resource done, I need to go and instantiate it in code. And rather than poke through my source files, instead, I’m going to take advantage of a feature that Visual C++ 6.0 developers know and love: it’s called the MSD Class Wizard, and we’ve brought it back. Let’s hear it; where are my native developers? Come on, folks.

BOB MUGLIA: Good to have this back.

SAM GAZITT: A few of you in the audience. OK, so I know that my mainframe class defines my main window, and I’d like to go add a variable of the Ribbon bar type. Great. And I’ll give it a friendly name here. Great. Let me hit OK. And now let me jump into my main form. OK, let me go and browse to the place in the code where we defined the old toolbar, and that’s here. I’m going to replace all of this with some code that I have in the toolbox here to go and instantiate the Ribbon.

Great, let’s preview and take a look at our application here. Let’s try that again. OK, thankfully, we’re prepared with a backup here. All right, do a quick build. All right. All right. So, here’s my application here. One thing to notice is we’ve got some great animation support. I can page back and forth here, and let’s go and fire up our application with the Ribbon installed as well.

All right, we’ll do another quick build here. We’ll give it a second. All right. Here we’ve got a Ribbon installed, and we’re able to take advantage of the folder that we added. So, we can certainly browse for images. And, again, I’ve got some great animation support as I go back and forth here through my images.

Now, one thing to note here is that I’m on a multi-touch machine, but I get some single-touch gestures. So, I can certainly touch an image and have it open up here. That’s great. But we’re on a multi-touch machine; let’s add support for advanced gesturing. Let’s add support for the flip gesture as well as the zoom gesture. All right. Let’s bring back our trusty friend, the MSD class wizard. And this time we’re going to go into the photo viewer view class; OK, that’s here. And I’m going to add a handler for the app command message. That’s here. Great. And this time, I’ll use the class wizard to jump directly into code, and here I’m going to implement my handler.

OK, let’s pin that. All right. Let’s add the flip gesture. And while I’m here, let me go add support for the zoom gesture as well. I’ve got that here. Now, I just need to go and update the header with the destination. OK. Let’s take a look at our final application and see what we have. Give it a second to build. Oh, OK. (Laughter.) This is a fun, fun day. (Laughter.) All right, we’re going to give this the old college try here. OK.

So here’s our final application in the underscore complete version. Here is I-touch; I certainly get single-touch support, but you’ll notice I’m able to flick back and forth, and I get some great flick gesturing as well. That’s pretty cool.

Now, let me flick through to my final image here. Let’s take a look at the support for gesturing as well. That is awesome, I get to zoom in as well.

BOB MUGLIA: Very straightforward to take and add multi-touch and overall touch capabilities to an existing C++ project.

SAM GAZITT: Absolutely. So, what we’ve seen here is that Visual Studio 2010 provides a great production experience for native developers. We’ve brought back some of the features that Visual C++ 6.0 developers know and love, and we’re very quickly able to light up a Windows 7 application to deliver a great end user experience. Thank you, Bob.

BOB MUGLIA: Thanks a lot. (Applause.) Why don’t you hang around up here to debug that application, OK, and I’ll be back in a second with you.

SAM GAZITT: Sure. (Laughter.)

BOB MUGLIA: Well, there’s always little challenges with developing software; that’s part of the challenge.

So one of the things you saw there is how we put a lot of focus into helping native applications, C++ applications move forward and take advantage of some of the really, really great features in Windows 7 and really modernize those applications with things like a Ribbon and touch support. We know there’s massive investment in native applications, and so we put a lot of energy into Visual Studio 2010 to help native developers bring their applications forward, and also to create new applications as it’s appropriate with native code. So, a lot of great stuff there.

One of the areas that is exploding right now is the focus on collaboration and portals and SharePoint is just sweeping the planet. Again, talk to any major customer and they are either well on the way of deploying, or are looking to deploy SharePoint. And the kind of things people are building, the kinds of applications that people are building with SharePoint are very broad. There’s, obviously, a very large number of team collaboration applications that are built with SharePoint, but there are many business solutions where SharePoint becomes the central dashboard for an organization to understand what is happening in their business process.

So there’s a massive opportunity to take all of the various types of business processes that exist within an organization, and build them as SharePoint solutions. And the demand for this is just off the charts. Every customer, lots and lots of solution providers, tremendous opportunity to build SharePoint applications. But building SharePoint applications has been very, very challenging. The environment was not as well set up to help make the developers productive as they could be.

Well, all of that is about to change. The combination of SharePoint 2010 and Visual Studio 2010 is a whole new world. And so, Sam, let’s do SharePoint.

SAM GAZITT: Let’s do it. All right, so you spoke about some of the great new features in SharePoint 2010 and how developers are excited about the first-class tooling support inside of Visual Studio. You also mentioned how existing Web developers can leverage their current skills to get up to speed. So, let’s take a demonstration — a demonstration of how Web developers at Blue Yonder can build their very first SharePoint customization.

Now, I’ve got an empty SharePoint project here, and right off the bat we see some of the great tooling support in VS. We can see how Visual Studio captures our features as we add them to the project, and enables developers to go and specify how they want them packaged and deployed. Deployment was one of the big pain points for SharePoint, and Visual Studio is automating some of that manual pain.

We’re going to talk more about that automation in just a bit, but for now, let’s go and add a new feature to our project. So, we’re going to add a new item here, or add a new visual Web part. Visual Web parts are new in SharePoint 2010, and we’ve got some great template support here in Visual Studio. And our goal here is to create a Web part that surfaces data inside that comes from SharePoint.

So let’s call this high-priority issues. And let’s add it to our project. And as I hit “add” here, Visual Studio is going to open up something that should be very familiar to Web developers; namely, it’s the Web forms designer. And I can go into split view here. And as you might imagine, I’m able to drag and drop controls into both windows here, to go in and visually lay out my Web parts.

BOB MUGLIA: So if you’re familiar with using ASP.NET Web forms, you’re familiar with visual Web parts?

SAM GAZITT: Exactly right.

BOB MUGLIA: And one of the key things we’ve done with SharePoint 2010 is enabled you to use Silverlight as a part of visual Web parts. And we’re not going to show that this morning, but that’s one of the things that’s very possible, and there’s been some incredibly creative new solutions built around the combination of SharePoint 2010 and Silverlight.

SAM GAZITT: That’s exactly right. OK, so let’s go and build our Web parts by dragging and dropping a list view here. List view is a fairly common control. And we can certainly data bind it here, we can style it here. But instead, I’m going to take advantage of some markup that I have here on the toolbar to do that step, and let’s synch the designer here.

Notice that we’ve got a data-bound list that’s pretty straightforward here. We’re doing some styling. We’ve got a layout template, we’ve styled that, we’ve got an item template, we’re doing some styling and some data binding. And speaking of data, I need to go and connect to some of the assets that are inside of my SharePoint server. Now, I have SharePoint running locally here on my Windows 7 development box. That’s pretty cool.

BOB MUGLIA: People, one of the biggest complaints that we’ve heard from developers is the complexity associated with building — one of the first for many, but one of the first complexities of building SharePoint applications in the past was that you had to deploy a SharePoint Server on a Windows Server. And so you couldn’t take and run SharePoint on your local development box. With SharePoint 2010, the SharePoint team has fixed that.

SAM GAZITT: That’s right. So, I could certainly use a Web browser to browse through the SharePoint site that’s running locally on my machine, but instead, I’m going to do better than that. I’m going to stay inside Visual Studio and use the server explorer to go and navigate my SharePoint connections.

Now, developers that have worked with data inside of Visual Studio should be familiar exploring with exploring their database via server explorer. Here, I can explore my SharePoint site. I can see all of the assets that are in SharePoint. I can take a look at the lists, for example, and you’ll notice that I have a high priorities issues list. This is the data that we want to surface in our visual Web part.

So what we’ll need is a data model. And we’ll go and create that here; we’ll generate it in Visual Studio. And once we have that generated for us, we’ll be able to go and leverage that using Language Integrated Query. So, here you can see the file’s been added to my project. Let’s jump in the code and let’s write a little bit of the code behind. Ah, here’s our old friend the page load method, should be very familiar to Web developers. We’re just building an ASP.NET user control. And, first, let’s go add a using statement for LINQ, or Language Integrated Query, was first introduced in Visual Studio 2008 and enabled developers to work very productively inside of a managed language like Visual BASIC or C# with data. And here, we’ve extended the concept of LINQ to include SharePoint as yet another data source.

BOB MUGLIA: So it really just shows that what we’re doing is treating the SharePoint environment, the SharePoint platform, as just one of the sources of data. SQL Server or other objects you might have. Obviously, for a while you’ve been able to use LINQ against that; we’ve now made that extension against SharePoint.

SAM GAZITT: That’s right. Let’s drag in some code here to go and create a data context. We’ll go and issue a LINQ query against that data context. We’ll return data source and do a data bind. Pretty standard stuff. Now here comes the magic. I’m going to set a break point here. Now there are some people that are sort of getting up and leaving right now, those are our current SharePoint developers. And they’re leaving to go grab coffee, because in the past, this was a painful, painful process. There were 17 manual steps involved in developing, debugging, and deploying SharePoint.

BOB MUGLIA: How long would it take to do those 17 steps?

SAM GAZITT: Well, how long does it take to grab a big cup of coffee?

BOB MUGLIA: So you have to do the work, too. So, you can’t even go get your cup of coffee. Now at least you can let Visual Studio do it all for you.

SAM GAZITT: That’s exactly right. We’ve taken all of that power and put it directly here into my right index finger. I’m going to hit F5 and Visual Studio is going to do all of this work on my behalf. It’s going to recycle the app pool, it’s going to retract a solution, it’s going to package up my solution, it’s going to deploy my solution to SharePoint, it’s going to attach the debugger to my SharePoint site here, it’s going to bring up SharePoint under the debugger. I’ll be able to go and interact directly with the Web part that I just created. No more working with manual XML files: boom, we just pop directly back into Visual Studio, we hit our break point, we have all of the rich debugging support that we’re used to, we’ve got a call stack and break points, we’ve got locals and watch variables; that is a great development experience. (Applause.)

OK, let’s clear our break point, continue debugging and bring up our Web part inside of SharePoint. Here is our finished Web part here. We’ve got some customers and they’re complaining. Someone says, “I didn’t get a pillow.” Long flight for someone without a pillow.

BOB MUGLIA: He went to India for his launch event, that’s a long way.

SAM GAZITT: And Julia flew to China and she said the salmon tasted like cardboard. So, we have some unhappy customers of Blue Yonder Airlines. But the good news is our customer service department is able to use this visual Web part to more quickly answer their complaints. And what we’ve seen here today is that they can leverage their existing Web development skills to very quickly build their first SharePoint customization. Thank you.

BOB MUGLIA: Thanks a lot, Sam, appreciate it. (Applause.)

So what we’ve done with Visual Studio 2010 and SharePoint 2010, very simply, is make SharePoint a first-class platform for building business applications. And I think it’s very exciting. It’s all about, once again, making the developer more productive, enabling them to do more faster, and the combination of these parts, unambiguously, will do that, so we’re very excited about that.

Now what I’d like to do is shift gears and talk a little bit about the cloud and also about the breadth of devices that will be connected to cloud-based applications. There’s no question that the cloud is going to have a very significant impact on all of us, on our lives, as well as on the way businesses operate and businesses work. Very simply, the cloud is a next — enables a next-generation application model that provides the ability to build scale-out applications that can lower the cost of operations and enable solutions to be built in a way they could never be built before.

We see the cloud as a major transition point. We also see the cloud as a next-generation application model. When I look back over time and think about similar transition points, I would say the PC was the major transition point, a major inflection point, the Internet unambiguously, was a major inflection point. The cloud, likewise, is a major inflection point.

And what we see possible with the cloud is to revolutionize, really, three major aspects. First of all, the cloud will change the nature of the way hardware is built and hardware is purchased. We see that today in the way large data centers are being built out, and the kinds of impact that this can have, even in smaller data centers, as customers begin to think about how they implement their own private cloud.

I can look inside Microsoft and our history at Microsoft to see how this is taking shape. Ten years ago when we were building out MSN, one of our many Web properties, our consumer-facing Web properties, we bought servers from our OEMs, and we took those servers and with screwed them into racks and we wired them up.

About five years ago, we stopped buying servers, and we bought from our OEMs pre-configured racks that were all pre-configured and pre-tested and pre-wired, and we would roll them into our data centers and then plug them in and validate them.

Now we’ve moved to buying containers, which are effectively large shipping-container-sized boxes filled with roughly 2,000 servers, and potentially petabytes of storage. And these servers, very literally, are trucked in. They weigh about 60,000 pounds, these containers. And we hook water, power, and Ethernet up to them, and then we validate it.

Now, when we look inside these containers, we see a very significant transition in what OEMs are building, and we’re very focused on working with our OEMs to drive the cost of hardware down. You can look at every piece of plastic, every screw, everything inside that container. And if it’s not compute, storage, or memory, it’s sort of superfluous and how can we drive the cost way, way down?

We see through the cloud in this focus the ability to have an order of magnitude, 10X improvement in the cost of hardware: big change, big change. These changes that companies like Microsoft are driving with our large-scale data centers will translate into benefits that are seen by all companies. Whether they’re using this technology to build their own private cloud environment or whether they’re a small business that are acquiring services that utilize this underlying hardware technology.

The second piece that’s very important is the operations model, how the operations model is used. And when you think about the ratio of how many administrators it takes to run a server farm, there’s a gigantic cost savings that is possible there.

The largest cost that is paid in terms of IT running data centers is in the operations side and the people cost associated with this. And it is common for our customers to have a ratio of about one operator to 30 servers; that’s common in the industry. A world-class IT organization will run at one to 300. When you’re deploying hundreds of thousands of servers, you can’t possibly operate in that sort of scale. And we’ve learned through services like Bing, which literally have hundreds of thousands of servers, that we can dramatically, through software, cloud-based software, we can drive the cost of operations down, and have a ratio of about one operator to 3,000 servers. So, that’s actually two orders of magnitude in reduction of operations cost: people cost relative to what most of our customers are doing, or one order of magnitude, 10X, compared to the best sort of environment that we typically see in most of our customers.

The third piece is probably the most dramatic. While it’s certainly important for existing applications to run in the cloud, and we will enable that absolutely, it is also true that the cloud enables a next-generation application model. And in some senses, this is the fifth-generation application model. We’ve seen over time the mainframe or monolithic application model, the client-server application model in the late ’80s, Internet, mid-’90s, SOA, or Web services around 2000; now we see the cloud application model being introduced.

The characteristics of this application model are applications that are designed to be elastically scaled, applications that are model-driven with staged production to enable them to always be available. These are attributes that are interesting not just for the most mission-critical applications, but in fact, are interesting for a broad set of applications. And one of the key objectives Microsoft has is to take our customers forward and to take the many investments that our customers have made in building client-server, Internet, SOA applications forward into the future.

And so we know that many applications will just run in the cloud without taking advantage of many of these new characteristics of the application model, but some will want to take advantage of it, and we will focus on making it easy.

And the way we’re doing this is to think about Windows Azure as the next-generation cloud platform that Microsoft is doing and delivering it as a service. And Windows Azure fundamentally is built on our server products. Starting with the bedrock of Windows Server, but also SQL Server, our AppFabric, .NET — all of the characteristics that developers are familiar with, we’re bringing into Windows Azure, but then we’re learning what it takes to build these next-generation cloud applications. And doing what we try and do all the time, which is making it easy for you, the developer, to take advantage of this.

Sure, there are a few companies in the world that today have the resources and knowledge to build cloud applications. Our job is to allow every company on the planet, every developer on the planet, to easily and simply build these next-generation cloud applications. And that’s what we’re focused on doing.

Now, the other part of this is connecting to a broad set of devices. Certainly, the most popular device that we’ll be connected to is Windows itself and the PC, and that will be broadly used. But many devices will also be used, and the Windows Phone generation, Windows Phone 7 Series, we see is a giant leap forward in terms of enabling developers to build mobile applications.

What we’ve done with Windows Phone 7 is taken the knowledge that people have today to use .NET, to use the constructs in Silverlight to build mobile applications and to connect those to back-end server services, whether they be Windows Server-based solutions or new cloud-based solutions utilizing things like Windows Azure.

And so with that, what’d I’d like to do is invite Orville McDonald up to show you how you can take the skills you know today to build Windows Azure and Windows Phone 7 applications. Orville. (Applause.)

Good morning.

ORVILLE MCDONALD: Good morning, Bob. (Applause.) Today I’m going to show you how with Visual Studio 2010 and your existing skills, you can develop services for the cloud and applications for the phone.

I’m currently working on a Blue Yonder Game Lobby application. This allows me, while I’m waiting for my flight, to play against other people, or when I’m on the plane, if they have an on-board Wi-Fi system, to use that.

I also have a list of contacts that sit in the cloud. What I’m going to do today is I’m going to take my existing Game Lobby application and extend it with this information that’s in the cloud.

So let’s get started. The first thing that you’ll notice is that within Visual Studio 2010, it includes integrated templates for developing cloud services. It also includes roles that enable me to develop different type of services. In this case, I’m developing a Web service called friend service. And this is what will include kind of all my contact information that will be called by the phone.

As you can see, Visual Studio right now is configuring my application for me, and the first thing I want to do is add an operation contract. This operation contract enables me to call this Web service from my phone. And once again, I’ll call this phone service. You can see it’s added within Visual Studio; it also includes stem code, so that way I know what needs to be updated. Just going to add an interface, you can see it here.

Now that I have my interface, the next thing I need to do is connect with my data. Currently, my data sits within a SQL Azure database. I am, however, able to model that data locally within my project. Very simply, you can see my ADO.NET entity data model; here I’ll call it my Game Lobby, connect to it; you can see that I’m going to generate it from an existing database. There’s my SQL Azure database right there.

BOB MUGLIA: One of the things we’ve done with SQL Azure is we focused on making it very consistent with SQL Server, and in fact, one of the biggest differences you see is that you use a URL to connect to it. But if you look at the feature set that exists with SQL Server today, our goal is to build up SQL Server Azure over time to have a very compatible feature set. And we’ve come a fairly long way over the last 18 months or so. We are focusing on continuing — and it’s a service that will be rapidly adding new features to SQL Azure, but if you know SQL Server, you know how to use SQL Azure.

ORVILLE MCDONALD: That’s exactly it, Bob. And you can even see here that I’ve connected. I’m just going to import some tables. And the great thing about this is that it all works locally. Even though my data is in the cloud, so I’m using it just like I’m running SQL Server on my machine. You can see my table right there.

So what I need to do now is just connect to it. Once again, I have some template code. And I just update that. The next thing for me to do is to debug my cloud service. One problem with cloud service development is that I create my service locally, I finish with it, I deploy it to the cloud, I find issues, I go back locally to fix it. After a while, all these round trips start to get really expensive. However, the great thing with Windows Azure development is I actually get to develop and debug my cloud service locally, and then with all the great tools available to me in Visual Studio, I can find my problems and then when I’m finished, publish it to the cloud.

BOB MUGLIA: So we’ve built a local dev environment that simulates the way Windows Azure works, and enables you to build and debug these applications locally before you deploy them into the cloud.

ORVILLE MCDONALD: Exactly, Bob. And you can see here, I have it running locally.

So we just covered quite a few things. So, let’s do a quick recap. We’ve seen that with my existing skills and Visual Studio 2010 I can develop Windows Azure services, I can have my data hosted in the cloud using SQL Azure and then I can debug my application using all the great debugging tools in Visual Studio locally, and then, when I’m finished, publish to the cloud.

BOB MUGLIA: So in this case, what Orville’s done is he’s built a service; and one of the characteristics that we’re focusing to enable to make simple with Windows Azure is to take advantage of these next-generation cloud application model features, things like the ability to elastically scale out, or have stage production as associated with it. And so the characteristics of the platform enable these kinds of applications, and the tool, Visual Studio, unlocks those.

ORVILLE MCDONALD: I had previously published my Web service to the cloud. And as many of you remember, a few weeks ago at MIX, we announced the release of our Windows Phone developer tools. Today, I’m going to take this Web service that we just finished building, and I’m going to consume it within a Windows Phone application.

So let’s get started. The first thing I would like for everyone to notice is the side-by-side designer and XAML view. This enables me to update my UI in the manner that suits me best.

Another thing that I like to point out is if you look within my toolbox, you’ll see a list of controls that are familiar to anyone who’s done Visual Studio development before, and if you’re new to it, they’re actually quite intuitive. You can see here that I grabbed the button, I dropped it onto my designer, it automatically took on the look and feel of the Windows Phone design system. Also with the grid layout, it made it very easy for me to lay it out precisely. So, if you’re someone like me and you’re not necessarily the best designer, Visual Studio helps you to get productive really quickly.

BOB MUGLIA: And so if you’re familiar with Silverlight application development, you already have the basis of knowledge to apply it to build Windows Phone 7 apps, because this is all, effectively, Silverlight running on the Windows Phone.

ORVILLE MCDONALD: That’s exactly it. All Silverlight developers today are already Windows Phone developers using their existing skills. So, you can see here that I’ve updated my page; I’ve added a button. Now it’s time to power it with the Web service that we just finished building.

So I’m going to go to add service reference. Go out to the cloud and pull it in. And many of you might be looking at me saying, “There’s nothing special here.” And you’re right. What we’ve done is if you’re used to adding Web services to your applications, it works the exact same way for the phone as well.

BOB MUGLIA: So because the phone is effectively another first-class device that we’re supporting with Visual Studio, all of the skills that you have transfer right onto that. One of the other key points is because the environment is based on Silverlight, all of the Expression Blend tools can be used to style your applications and have designers create the characteristics that will make that application look fantastic.

ORVILLE MCDONALD: Definitely true. So, now I have my phone service connected. So, now let’s finish off this application. The first thing I’m going to do is add a line of code for navigation right here, and then we have this Web service that has all these contacts. Now I need to bind it to my phone application. I’m going to add a few lines of code here. Now, it’s time to debug it. One thing I would like for everyone to notice is that within the Windows Phone emulator, not only does it have the look and feel of a Windows Phone device, but it also includes functional buttons, so that way, even before you get the device, you could start developing your Windows Phone applications starting today.

BOB MUGLIA: Well, in some cases, I was thinking more than that because the emulator is actually running an instance of the Windows Phone 7 operating system locally on your development box. So, it’s really a full emulation environment, but it’s available as a part of your development experience, fully connected with debugging, and fully connected into Visual Studio?

ORVILLE MCDONALD: Correct. So, now that you can see we have my application, so let’s give it a try. So, we see a list of games. Marionette seems to be pretty popular, so we’ll select that one. Now I’m going to find my friends. This is the button that we just finished adding. You notice how we hit this breakpoint. There’s tight integration between the emulator and Visual Studio. There are five keynotes going on throughout the world today, one of them being here in Vegas with Bob. So, I’m going to click on you out of my friends. See my marionette? I pulled in the pictures from everyone in my contact list. I’ll select Bob. Bob’s flexing. And in celebration of the launch of Visual Studio 2010, we actually have a commemorative T-shirt for you, the VS Launch. (Laughter.) (Applause.)

BOB MUGLIA: What’s amazing is as developers have had a chance to play with this environment, which is only just a few weeks now we’ve put it in developers’ hands, the reaction for developers in terms of the kinds of applications they can build and how simple it is to build incredible-looking applications — we’ve almost never seen such a positive reaction. So, Windows Phone 7 has gotten a very strong positive reaction, but also the development environment, the design environment is really what’s lighting it up.

ORVILLE MCDONALD: And I’ve been having a lot of fun developing applications for Windows Phone. But it would be really nice if I actually had a phone that I could play with.

BOB MUGLIA: You need a phone?

ORVILLE MCDONALD: I need a phone.

BOB MUGLIA: I’ve got a phone. (Laughter.) Here you go.

ORVILLE MCDONALD: Great, thank you, Bob. So, one thing that everyone should note is that later this summer, the Windows Phone — or I should say later this year — the Windows Phone Marketplace will be updated to start accepting Windows Phone 7 applications. So, as you go out and you develop applications, and you can see this is actually a real app running on the phone with the orientation changed, is that you’ll be able to go and with all the great work that you’re doing now with these apps that you’re developing, you can actually release them for others to play with and enjoy. And you can see there, the exact same application that I had running on the emulator is now running on the phone.

So we’ve just covered quite a few things. So, let’s do a quick recap. We’ve seen how, one, with Visual Studio 2010 and my existing skills, I can develop Windows Phone applications. Two, I can connect those with Web services that I could also build using Windows Azure and SQL Azure. And, three, that later this year, I’ll be able to then upload onto the Windows Phone Marketplace and share them with other people who would like to play with them.

BOB MUGLIA: Great. Thanks a lot, Orville, appreciate it. (Applause.)

ORVILLE MCDONALD: Thank you, Bob.

BOB MUGLIA: So supporting a broad range of devices and enabling this next generation of cloud applications to be built all based on the skill set that you already know, that’s really our core objective. The technology changes; the opportunities that the technology opens up is tremendous. Our goal is to enable you to take the skill sets you already have and carry that forward into this new world to be able to build these incredible new solutions. It’s pretty amazing, the potential for what this technology can deliver, and what you will do with it.

So one of the interesting challenges we all face is, as I said, most products that are built today, most solutions involve teams. You know, we see startups, small groups of people being able to do some incredible things with just a person or two, but ultimately, almost anything over some period of time becomes a larger project, and there’s a broad set of people that need to work together.

Now, there is a phenomenal opportunity to use software to enable teams to work together much more effectively. In fact, when I think about the way teams work together today and the kinds of inefficiencies we have, there are phenomenal things that can be done by having the development system provide an infrastructure to enable people to work better.

There are a lot of different challenges here; one of the challenges that certainly exists is that for most large organizations, they live in a heterogeneous world. A Windows Server may be incredibly successful, Windows clients may be what’s deployed on the desktop, but they have a broader set of environments they need to support. Certainly Unix and Linux is an important environment that we see exist in many customers, maybe most customers. The Mac exists out there, and so being able to support this heterogeneous set of developers that need to work together, not just on .NET, but also with tools like Eclipse and Java, are also very important. And what we would like to do is to enable all of those developers that are working in this heterogeneous world to be able to take advantage of the latest and greatest things to come from building application life-cycle solutions using Visual Studio.

And so today, I’m very pleased to announce the availability of Visual Studio Team Explorer everywhere. Yeah, this is a pretty big deal. (Applause.) This is part of what we’re delivering with Visual Studio 2010. The family of products in Visual Studio 2010. It is fully connected into the Visual Studio development environment and the Team Foundation Server environment, for source code development. It works with Eclipse, it works with Java, it works in Linux, it works on the Mac, it works on UNIX. It’s based on an acquisition we did a little while ago called Teamprise, and it’s now fully integrated and part of the Microsoft solution set for developers.

And, you know, again, it’s our focus on helping developers to solve the problems they face and to meet the challenges. There’s a lot that can be done on the Microsoft platform, but the reality is it’s a heterogeneous world, and we want to help developers with that.

So when we think about challenges that developers face in general, there’s a tremendous set of things that can be done on the Microsoft — on a platform to help developers work together. Yeah, I think we’ve all seen something like that as we’ve been through code. I don’t know if — I have to think back a while to think whether I would have written something like that or not. But you’ve all seen the challenges of working with code that you didn’t write or, frankly, even code that you wrote a really long time ago and that you were involved in. And teams build projects, and code is difficult to understand.

Well, there’s a lot of semantic knowledge locked up inside the code; maybe not in the comments, but in the code, there’s a lot of knowledge. And there’s a lot we can do to unlock that knowledge and put it in the hands of you, the developer, working in a team to understand what the code is doing to better be able to debug it and fix it, enhance it as your needs dictate that.

Another interesting thing is sharing — is sharing the information about the project. Status meetings are a reality for a development team. Some of them are pretty boring and the worst part is not just the fact that there are these time-consuming meetings, but also the fact that it requires a lot of time for developers to prepare for these meetings, and they have to do a lot of manual work to build the reports and to indicate the status.

Well, Team Foundation Server has a lot of that knowledge; a lot of knowledge about what’s really happening in the project can be built into the system. And, in fact, we can do a lot to unlock that and to allow the project to overall be managed and that information to be shared with others. And so we’ve done a lot in Visual Studio 2010 to take information that the system already knows and enable it to be shared with others as a part of the overall project management.

So once again, developers can put their focus on what they do, which is writing great, world-changing code.

Another thing that is always an opportunity is how we can help developers find the problems, the bugs in their software. Could have helped Sam out a little bit earlier on that, and there’s a lot of challenges that we all face as we build our applications to look at the bugs that exist as we write our code. And some of those bugs are really hard to find. The ones that are the worst ones are the ones that are very intermittent; they run in a server environment, they take a long time to reproduce, and it takes developers a lot of effort to actually find those bugs.

A lot of bugs are found by testers that are brought back as non-repro, because the tester, as they test the software, they find a problem, but the way they document it, the developer doesn’t understand. So, time is wasted going back and forth between the developer and the tester just for the developer to understand what the tester was saying with the problem.

Again, the software can really help this and make it a lot easier for the overall process and all of the people in the team to work as effectively together as they possibly can.

And with that, what we’d like to do is invite Doug Seven to come up and show us some of the application life cycle management features that are part of the Visual Studio 2010 family. Doug, good morning. (Applause.)

DOUG SEVEN: Thanks, Bob. You know, I’ve got to tell you, I am excited to be here. This is three years in the making, and this is great to be able to show off these tools. And, you know, you talked about all of the challenges that all of us face with existing code. The truth is, 80 percent of you in the room right now today go to work every day and you work on existing code. So, how do we make that process easier?

Within Visual Studio 2010, we have the ability to create these visualizations of your code. Rather than reading the code, imagine if you can create a picture of what that code looks like and what all the connections are. In this case, I can create a dependency graph that shows me a different perspective, if you will. I can look at it by assembly, by namespace, by class, and I can create a diagram that represents that code.

So, Bob, to speed things up, I went ahead and created one already. This is an assembly perspective. So, what I’m looking at is at the highest level, sort of the physical artifacts that I’ve produced, my VLL, my Blue Yonder Web VLL.

BOB MUGLIA: So the add-on features of Visual Studio 2010 have gone out and actually analyzed an existing project, looking inside the source code itself, and have an understanding from that of the main modules and the relationships between those modules?

DOUG SEVEN: Exactly. What this did is analyze the code and create a visualization of all of the different aspects of my code. So, I can see that there’s a VLL; I can see within that VLL, there’s a namespace; and within that namespace, there’s a booking controller class.

This really helps me understand sort of the high level, and this is a WPF-based system, so I can zoom in on it and use that sort of surface interaction to make it easier for me to investigate.

And as I look through this, what I’m seeing is all the different nodes within my application. These represent classes. In this case, you’re seeing all the methods within booking controllers, and all the arrows sort of indicate where the connections are.

Now, you can imagine as a Blue Yonder developer, if I needed to work on the external rule validation, I could click on that node. This is a method call. And what it’s showing me are where the dependencies of this method call are. In this case, it has a dependency on an external assembly, Blue Yonder Logic VLL.

Now, this is a model-view controller-based application, so I can also navigate up through the call stack and see how this method is being used. You can imagine if my diagram were a lot more complex and a lot larger, this would be a really great way to navigate around through the code. This gives me a really great sort of coarse-grained look at my code in understanding where all the dependencies are. But if I want to work on the code, I still need to understand the control flow and how things work.

So as I click through, I’m taken right to that point in the source code because, again, this is just a real-time view of what my source code is doing. So, here I see the “create” method; sure enough, it calls the “validate external rule” engine method. This is good, but I still don’t know what happens here. If I’m going to make a change, I really need to know what this method does.

So if I right-click within this method, I can generate a sequence diagram. I’ll accept the defaults here. Now, again, this analyzing my code and looking at the calls. And based on the call depth I told it to look at, it’s creating a UML 2.1-compliant diagram that shows me the control flow. This is great, don’t you think? (Applause.)

BOB MUGLIA: So that’s really getting in there and understanding the way the modules are connected and the way —

DOUG SEVEN: Exactly. I can look at this and I can see where the create method is called, and I can follow the control flow through. And I can see there’s things like loops, and it’s UML 2.1 compliant. This is now an artifact I can save and version within TSF, so this really helps me get an understanding of the code.

BOB MUGLIA: There’s a broad set of UML views that are built into Visual Studio, right?

DOUG SEVEN: Absolutely. We support the five UML diagrams. Five of the 13 diagrams right out of the box, this being one of them. So, this is really helpful.

One of the things you talked about, Bob, was finding bugs. The reality is, we’re human. I don’t do this, but I’m sure it happens to people. There are bugs that get introduced into software, and so we need to find better ways to not only find the bugs, but fix the bugs.

So I’m going to go ahead and open up my bugs report here. And I can see that I’ve got a critical bug assigned to me. This says an unhandled exception occurred when booking a flight. Not the desired result.

So I’m going to go ahead and open this up. Now, the interesting thing about this is this is a bug that was filed by one of my colleagues who was using Microsoft Test Manager. This is a new product we’re introducing in Visual Studio 2010. We refer to this as sort of an actionable bug. In other words, when I get a bug, when you get a bug assigned to you, what you want is to see the bug, understand it, and take action immediately. Oftentimes, as you mentioned, Bob, that’s not the case.

So I’m going to go ahead and scroll down. And what we see here are steps to reproduce. This tells me exactly what the tester did when they found this defect, and I can see which steps passed, and there’s a video link next to them. This is really cool.

BOB MUGLIA: So this is really how Visual Studio is focusing on the overall test and overall development process to enable the tester, as they’re testing the application, to capture, step by step, what they did as they ran their test, and then to pass all that information back in a pre-configured form as a part of the bug report to the developer.

DOUG SEVEN: Exactly. What you can imagine here is the tester went through all of these steps. And as they finished each step, they clicked whether it passed or failed. And you can see the last step failed, and we need to figure out what happened there.

Now, with this video link, I can click on it and this will open up a video. This is an actual desktop recording. Let me go ahead and zoom in, make it full-screen. This is an actual desktop recording while the test case was being executed. I’m going to go ahead and pause that so we can see what happened here.

This is essentially me standing over the shoulder of the person that ran this test case and saying I want to see for my own eyes what happened. Well, this video recording is captured automatically, automatically associated to the bug, and the tester didn’t have to do anything extra to make that happen. Isn’t that cool? (Applause.)

So, Bob, I know for sure now that we have the unhandled exception, because I’ve seen it with my own eyes. I’m going to go ahead and exit out of the video.

Now, the video is great, the steps to reproduce are great; it’s certainly no replacement for actual debugging. Imagine if I could kind of go back in time and put my debugger on the machine the tester was using, and see what happened in the code while it was happening. Wouldn’t that be great; wouldn’t you like to be able to do that? Yeah?

So, what I’m going to do is use a new capability in Visual Studio 2010 called IntelliTrace. Now, this IntelliTrace file also was captured by the tester when they were going through this experience, and it’s automatically associated to this actionable bug.

So, I’m going to scroll down. In our case we’re looking for exception information. So, there’s a whole set of exception data here. I can see the departure and arrival date can’t be the same. That’s the exception I’m looking for. So, I’m going to go ahead and double-click on that.

Now, Bob, if you’re paying attention, one of the things you’ll notice is our debugger just got attached to this code. This is code that executed previously, potentially on another machine by someone else sometime in the past. I’m now debugging it.

BOB MUGLIA: So, IntelliTrace provides what’s effectively a flight recorder or a digital video recording of what was happening at the time the problem occurred, and the developer then is able to get a really good understanding of the environment, but not just that, actually go in and step through and debug the application, go backwards and forwards in the application.

DOUG SEVEN: Exactly. Just like a DVR, I’ve got controls to go forward or backwards through the execution. This is an execution that already happened. So, I can examine it, I can fast-forward, I can rewind, I can pause, I can replay; all of the capabilities you would expect of some sort of playback device on code that previously executed.

BOB MUGLIA: These are the sorts of things that we think can make a massive leap for the effectiveness of development teams in terms of solving problems and working together, to actually be able to have testers and developers working together in a consistent process, and most importantly for developers to be able to really understand all of the details of what was going on at the time the problem occurred, so that they can get right in and solve the problem.

DOUG SEVEN: Exactly. And right after lunch actually we’ll be doing a lot deeper dive into how this works and how the developers and testers can collaborate. It’s a great opportunity to see how this works.

Now, in this case, Bob, I can look at this really clearly and see what exactly happened. I’m going to go ahead and stop the debugger, because I know what happened. This is a pretty common sort of mistake. It’s a copy-paste error. I’ve got two different variables that are being instantiated, but they’re being set from the same value in a collection. This is an easy mistake to make. I’ve made it a few times. Easy mistake to fix as well.

So, I’m going to go ahead and build my Web project. Now, as a good developer what I would want to do is do a quick smoke test and make sure that the fix actually does fix this bug and make sure it works.

Because I’m using Visual Studio Ultimate I have the power to leverage the Microsoft Test Manager. This is the Test Manager, the new tool. It’s installed automatically with Visual Studio Ultimate, and your testers can install it individually as well.

What I’m going to do is run the exact same test case that my colleague ran, so I can go through the exact same steps that they went through when they found the bug.

BOB MUGLIA: To really validate if the bug is fixed.

DOUG SEVEN: Exactly. I want to make sure that what I did makes this unhandled exception go away.

So, as I run this, the UI sort of moves over to the sort of sidebar application, and I can start this test.

Now, normally I would have to physically go through all these steps and in this case it’s fairly short, but if it was a long test, this could take some time.

Somebody has already gone through this test, right? I want to take advantage of the work that they did. So, what I’m going to do is click Play All, and, Bob, I’m going to ask you to step back and make sure there’s no funny business going on here.

What we were seeing happen here is we’re actually replaying the actual keyboard strokes and mouse clicks of the tester when they ran this test case. This is a lightweight piece of automation designed for productivity that allows me to take advantage of the work they already did and replay this.

So, what we should see here is as this test case is completed, instead of an unhandled exception, we’ll see some flight results come up. This is a great productivity enhancement, don’t you think? (Applause.)

BOB MUGLIA: A focus on really simplifying the process of automation, and once again allowing the developer and tester to work together as effectively as possible.

They’re all part of a team. It takes a team of people to make these things happen, and our goal is to make them work as well together as we possibly can.

DOUG SEVEN: Exactly. So, now my test case is I can label this as pass. I’m pretty confident that this is ready to go. So, I’ll close that and that moves my test case from this failed category to a pass category. So, this is a way I can help my team out.

Now, one of the things you talked about, Bob, was status meetings. Now, there’s two things I know about developers. If you ask them how far they are along in the task they have at hand, they’re going to tell you it’s 80 percent complete and it’s going to take two more weeks. (Laughter.) The other thing I know to be true is there’s not a single developer in the world that likes doing project status reports. These are two things I know to be true.

Now, fortunately, Team Foundation Server gives us the ability to collect all the data that’s automatically being pulled in, just by the simple fact of doing your job. As you check in code, as you run builds, as you complete test cases, Team Foundation Server collects all of that information and aggregates it into a store that we can then query for data.

Now, one of the things you talked about was SharePoint and our integration with SharePoint. Well, we’ve done with this Team Foundation Server as well. We’ve now integrated with SharePoint to create these visual dashboards to show all of your project status. So, instead of spending your time reporting to people on how your project health is, you can just point your stakeholders or your manager at a dashboard, and they can find the information really easily.

BOB MUGLIA: Well, SharePoint is all about helping teams work effectively together. So, of course, we’re going to apply that environment to the development team, enabling developers, testers, designers, everyone associated with the process of building great code to work as well together as possible. In this case, Team Foundation Server has a tremendous amount of information about the project, so why can’t it just provide all that information and allow those project status reports to be built without a lot of developer time?

DOUG SEVEN: Exactly, and let us developers focus on code and not project status.

So, here I can see we have some new enhancements for teams doing agile development. We have a burn-down dashboard, sort of a stable and agile development. And all of these are sort of aggregates and these are used in Excel-based reports that are uploaded to the dashboard, so leveraging SharePoint Excel Services.

Each one of these reports allows me to see sort of an aggregate of data. Each report individually tells me something, but as a collective they tell me something else.

So, we were looking at a bug, and here I can see sort of my bug progress, my trend reports, and, Bob, these are actually similar to the reports we use internally when we’re building Visual Studio. These same reports are used by our product teams.

As I scroll down here, what we’re going to see is our bugs by priority report. Bob, our last priority one bug has been closed. I think we’re ready to ship Blue Yonder.

BOB MUGLIA: That’s great.

DOUG SEVEN: Thanks, Bob.

BOB MUGLIA: Blue Yonder and Visual Studio. Thanks a lot, Doug. (Applause.)

So, the individual developer certainly, supporting the broad set of platforms certainly, but also very critically enabling teams to work effectively together.

You know, we’ve been thinking about the overall process, the overall life cycle of building applications from the very beginning to the end. We didn’t get a chance to really show this today, but we’re thinking about how you can test your code in an environment that really simulates production.

So, one of the features that is available within the Visual Studio products is the ability to use a virtualized test environment, a virtualized lab. This takes the combination of Hyper-V and built on our System Center technology, and enables you to have a virtualized test environment so that it’s very, very easy to deploy server instances within the test lab, to simulate the environment that can simplify things; and we’ve been working through all of the process from the point at which the project is defined, the architecture is designed, the code is written, the testing is done, all the way through and staging into the application going to a staged server and into production ultimately, and then, of course, as it’s maintained over a period of time.

That life cycle from beginning to end is what’s key to enabling the entire team to work as effectively together as possible, and Visual Studio 2010 will really set it on fire, so we’re very excited about that.

The products, as I said, they’re available today. It’s a great thing. It’s been a long journey. We’ve been working with all of you, and all of you around the world, on this journey in terms of building the products. We’ve focused on making development great for the individuals, and with our Visual Studio Professional Edition we have now included as a part of that something that we’re introducing with Visual Studio 2010, which is something called an MSDN Essentials subscription. This is a one-year subscription to the current version of our key platforms: Windows 7 Ultimate, SQL Server 2008 R2, and Windows Server 2008 R2, the datacenter, the highest-end versions of these products; so, really focusing in on enabling you to have all of the products in your hands to test and run your applications as a part of your development process.

And if staying current is important, this is sort of a taste-test for you to look at MSDN overall, which provides really all of our products, not just the most current but all of the products that have existed over time, all of our platforms over time for you to develop.

So, a very significant enhancement as a part of Visual Studio Professional for the individual developer, and we think it’s an important step in terms of enabling you to be successful as an individual building software.

We’ve also focused very heavily on teams in the application life cycle. We just showed that with what Doug came up and showed you a minute or two ago, but the overall process of teams working together.

And as a part of this, as a part of our Premium and Ultimate editions, one of the things we’ve had in place for a number of months is something that we call the Ultimate Offer for developers, which is a step up to the next-most-expensive SKU. So, if you’ve purchased a less expensive Visual Studio SKU in the past, we would give you a step up with Visual Studio 2010 to the next higher edition, so you really can see what the capabilities are, really all for free. This is, we think, the largest give-away to developers in the history of time. It’s literally over a billion dollars worth of software that we’re giving away as a part of this.

That program had been set to end at the release of Visual Studio 2010. So, it was supposed to end I guess yesterday. But what we’ve decided to do, based on input from everyone, is to extend that to the end of the month. So, through the entire month of April this Ultimate Offer will stay in place, allowing you to buy a lower-end edition of Visual Studio and get the higher-end version for free as a part of the package. So, we think that continues to be a nice offer. (Applause.)

So, it’s been a great and wonderful road getting here today. It’s a road where you’ve all participated, because it’s your input, the developer, the input from the developer, the community, all of our partners that have made Visual Studio 2010 possible.

As I said, software powers the world. So, that means that developers are the engine behind what powers the world.

And the kinds of solutions that you’ve built in the past using the tools and using the platforms that were available to you have been amazing. The work that you’ve done over time is really phenomenal, and something that you all have a right to be proud of. It just always amazes me. Nothing amazes me more than seeing what our customers do, the solutions that get built.

So, when we look at the power and the potential that exists in the modern platforms, Windows 7, Windows Server 2008 R2, SharePoint, SQL Server, new things like Windows Phone, Silverlight, and of course the cloud with Windows Azure, you take that power and you put it together with the world’s best tools to build, for developers to build these applications, I think the future is limitless.

There’s only one last question: What will you do with Visual Studio 2010?

Have a great conference. Thank you very much. (Applause.)

END