Tim Sneath

Over the next week or so, I want to put a bit of context behind some of the announcements from PDC, particularly the ones that got glossed over amidst the excitement over Windows 7 and Windows Azure. I’m going to start with highlighting some of the work we’ve done around WPF over the last couple of months.

Silverlight and WPF: Avoiding the Tyranny of “Or”…

We talked a lot at the PDC about how we’re continuing to make a very heavy bet on WPF as a platform. Hopefully folk spotted the significance of Scott Guthrie (usually known as the “web guy” and one of the fathers of ASP.NET) spending such a large percentage of his time talking about WPF. We’ve got a big team working hard at new investments in our flagship platform for building Windows applications, and the broad take-up we’re seeing from customers like Autodesk, Roxio, HP, Lenovo, AMD and others is representative of the ongoing momentum behind WPF.

An example of our own investment is in the controls space. At PDC we finally released WPF DataGrid, DatePicker and Calendar controls, all with both binaries and source code available under a permissive license. We’ve also shipped the first CTP of a ribbon control that mirrors the Windows 7 look and feel. (Of course there are some great third-party controls out there that add many valuable data views on top of a basic grid interface, like this one from Xceed). We span up a team a few months back that is focusing on building out controls, so you can expect to see many more interesting visualizations for both WPF and Silverlight over the coming months.

One leadership book that often does the rounds at Microsoft is Good to Great, by Jim Collins – it’s a personal favorite of Steve Ballmer’s, which might explain its popularity. It has one really impactful chapter called “The Tyrrany of ‘Or’”, which describes the false premise that one thing must always come at the cost of another. Silverlight and WPF are a great example of us not unnecessarily putting all the chips on one side of the table. We see a place for both rich internet applications and powerful Windows applications that can take full advantage of the underlying system. Both Windows and the web have their value – it needn’t be an “either/or” proposition.

At the PDC, this was best exemplified by a customer demo from Tesco, the world’s largest online grocery retailer and a major retail force in the UK and abroad. Nick Lansley, who heads up new technology developments there, gave a great demo of how Tesco are supplementing their existing ASP.NET-based website with a WPF-based “companion” application that is always available for quick purchases. Nick writes at length about the application, which is scheduled to go live in beta form early next year, on his blog.

Visual Studio 2010

As many folk will know, we announced at PDC that the new Visual Studio 2010 shell is being written in WPF. This applies both to the visual “chrome” and the code editor. I saw a demo of the new editor just before PDC, and it’s looking really strong. We’ll share more information at the upcoming TechEd EMEA and DevConnections events, but for now, here’s a screenshot:

.NET 4 also adds many new WPF features. We’ve not announced everything yet, but you’ll at least see intrinsic support for multi-touch, Deep Zoom and Visual State Manager (the last of which is already available in preview form), along with much requested improvements to text rendering.

Hotfix for VS 2008 SP1 WPF Designer

I wanted to close by publicizing a brand new servicing update “hotfix” for the WPF designer in Visual Studio 2008 SP1, since it’s the kind of thing that gets missed. You’ll want to apply this one – although there are no new “features”, it fixes a few edge case scenarios. Here’s a short list of the issues fixed:

• When a resource in an external resource dictionary is updated, Visual Studio 2008 crashes.
• WPF Designer cannot load read-only attached properties, such as the VisualStateManager.VisualStateGroups property.
• If some data is bound locally, and then the data binding is cleared, WPF designer reports an error message  'System.Windows.Data.Binding' is not a valid value for property
• WPF Designer fails to load in VS.NET 2008 SP1 (RTM) if the startup project is set to a Win32 project
• When you set and then delete the Source property of a WPF WebBrowser control, Visual Studio crashes.
• When you move a control which is using the MultiTrigger class or the DataTrigger class in the Style class, WPF Designer may throw an InvalidCastException exception.

Happy WPF coding!

It’s Sunday morning, and I’m sitting back-stage in the huge keynote room here at the PDC in Los Angeles. Watching some great demo rehearsals; things are shaping up well for the “software experiences” keynote which is my area of responsibility, and it’s going to be an exciting week.

I wanted to take a moment to tell folk about one of the innovations we’re introducing this year at the PDC. One of the big challenges with a large conference like PDC is figuring out how on earth you can attend all the breakout sessions you want. Wherever you are, you have a nagging doubt that you’re missing some really crucial, interesting information that’s being imparted somewhere else. Sure, we’re recording sessions for later viewing, but frankly, who has time to sit and watch 400 hours of content? It’s a great way to catch one or two extra sessions, but no more. And many of us are so attention-challenged that the idea of sitting passively for even ten minutes is a challenge!

Early this spring, I was thinking about whether we could tackle this problem in a different way. I’m a huge fan of getAbstract – an offering that provides 1-2 page abstracts of thousands of business books. Heck, almost all books in this category have just a few ideas padded into 300+ pages so that they can be sold in book form – you can get 80% of the value this way!

So - what would it look like if for every session we produced a succinct one-page abstract that distils the key information from that session in an easily accessible form? We’d provide a way for attendees to get more out of the conference and find out about technologies and solutions they might never have otherwise spent the time on; we’d create a valuable repository of searchable information that would supplement the video recordings and help viewers choose what to watch, and lastly, we’d provide a useful digest of the conference that would offer a lasting record of the event.

And that’s exactly what we’ve done. We have a team of volunteers from around Microsoft and beyond who have stepped up to be our “stenographers”. We aim to capture the core pieces of knowledge you’d learn from every breakout session; after a quick editing pass, we’ll make these available both in text form on the PDC website and after the event as a free e-book that you can download or have printed for you.

If you’re at the PDC, and you promised your colleagues that you’d send them comprehensive notes on the sessions you attended, you’ll be pleased to know that we’ve done most of the work for you! If you were unable to attend the event, you won’t miss out on the knowledge either – just download the e-book or receive it in printed form through an on-demand printer.

This is a bit of an experiment – it’s no small undertaking to write and collate abstracts from so many sessions. We hope it’s a worthwhile investment that you’ll find valuable, and we’re eager to hear your feedback, both about the concept and the implementation.

A gloomy, rainy Monday morning is rarely a pleasure to be savored, but today is a great day! We’ve signed-off on the final release of Silverlight 2 – every control has been added, the last few bug fixes have made it into the release, and it’s finally ready to relinquish the “beta” mantle.

Download links to the end-user runtime will be propped by the end of the day, at which point it will officially be considered live, and I’ll update this post throughout the day with additional information and links.

From a development perspective, there are a number of breaking changes from Silverlight 2 Beta 2, as noted here. (Note, however, that there are no breaking changes from Silverlight 1.0 – we have a philosophy of maintaining 100% compatibility between published releases.)

We’ve been working with a number of the biggest beta early adopter sites to get prepared for the final release – sites like Hard Rock, NBC Olympics, the DNCC and many others are either already working on the final “RTW” build, or are migrating across this evening. If you have a site that is using Silverlight 2 Beta 2, you’ll want to read through the breaking changes document and update your code as quickly as you can to minimize disruption.

The final build number is 31005.0; some of you may already have installed this build without knowing it – we quietly updated the RC build on silverlight.net through the last couple of weeks to the latest builds, and the version we released a week ago was the one that was declared RTW.

The image to the right demonstrates how this should appear in the “Silverlight Configuration” page – if you have a matching version, congratulations! You were running the final build already…

Congratulations to the rest of the team – it’s been a long road, and I’m proud to be associated with this release.

My favorite conference is almost upon us. If I’ve been quiet for a little while on my blog, it’s because this has been a crazy busy season for me and my team, as we put all the pieces in place for PDC2008.

PDC is Microsoft’s flagship conference, both because of the scale and depth of content, but also because it’s unique as a time when we open up as a company and share almost everything that’s been under wraps for the previous year or so.

This year is more significant than most – it’s been three years since the last PDC. That’s a lifetime in the software world – at PDC05, we hadn’t yet shipped Windows Vista, WPF, WCF, PowerShell, Visual Studio 2005 or SQL Server 2005. It’s high time we provided a set of deep, Level 400 developer sessions on new innovations like LINQ, C# 3.0, .NET 3.5SP1, Silverlight and so on.

But PDC isn’t primarily about shipping technologies. PDC is always a coming out party for the platform of the future. In the past, we’ve announced everything from .NET to “Longhorn” at the PDC (admittedly along with some blue sky projects that never truly saw the light of day, like “Cairo”). This year, we’ll be announcing a raft of new technologies that will impact every developer who focuses on Microsoft platform, whether your focus is Win32 or .NET, whether you specialize in server, mobile, web or desktop development.

At PDC2008, you’ll hear two primary themes resonating throughout the conference: Software+Services and Windows 7.

Software+Services
It’s hardly news that the Internet is transforming the software industry. We’ve seen it evolve from a loosely-coupled set of application-level protocols that spanned academic and military installations to a near-ubiquitous service to which billions of people are connected, with the browser having become by far the most pervasive means of accessing the net. Now we’re on the verge of a new transformation where the traditional lines of delineation are blurred – where Internet services enable the “cloud” to become the place where applications and data are hosted and accessed from rich client or browser applications alike.

You’re going to hear us reveal some significant new technologies at the PDC in this space. I’m obviously not going to pre-announce everything that we’re going to reveal, but the following quote from Steve Ballmer’s recent keynote at our partner conference will give you a few clues:

So what is the future? The future is about having a platform in the cloud, just as we have an operating system for the client, for the server, for devices. We will be launching a platform for the Internet cloud that lets you write programs and have them deployed and managed, that does computation and storage, and management, directly out in the Internet. We’re not getting rid of servers. We’re extending the basic programming model and management model that we know today from Windows and Windows Server to the cloud.

A platform for the Internet cloud? Doesn’t that sound like the kind of thing you’d hear a lot about at the PDC? Sure, you’ll be able to read a digested version of the announcements online, but there’s no substitute for meeting the developers and architects behind our new platform and attending all the deep-dive breakout sessions in person.

Windows 7
PDC has always been a “Windows” conference. At the first PDC I went to, ten years ago, the conference was almost exclusively dedicated to Windows NT 5.0 (which of course became Windows 2000). Almost every session focused on some aspect of the Win32 API. Of course, times have changed – the PDC is a much larger conference these days, and indeed the Microsoft developer platform has expanded hugely beyond Windows, a few server products and some scattered tools to encompass a portfolio of technologies so large that no individual can fully get to grips with all of it.

But the soul of PDC is still Windows, and this year more than most, Windows is a dominant theme. We’ll unveil Windows 7 to the world for the first time this year, and there are some exclusive surprises for conference attendees that mean you’ll be frustrated to miss out on being at the PDC in person. Although we’ve not yet unleashed the full set of tens of Windows 7 breakouts on the session planning tool, you can be sure that this will be a very significant part of the overall event.

We’ve revealed very little about Windows 7 so far. At Walt Mossberg’s D conference, we showed off multi-touch and there were a few other hints, but otherwise all you have to go on is rumors and mostly faked Photoshop renderings of what folk think Windows will look like. I’ve been running Windows 7 on my developer workstation in the office for some time now, and I think folk are going to like what they see. Among other things, we’ll be running compatibility labs at the PDC so you can bring your application and test it on Windows 7 builds. Don’t you want to make sure you’re ahead of the curve and, indeed, take advantage of some major new innovations? Make sure you’re at the PDC.

Other Stuff

I’ve not even mentioned some of the free goodies you’ll get for attending the event. Every PDC attendee will receive a 160GB external USB hard drive packed full of all the bits we’re distributing at the event. Yes, that’s right – the DVD package was just getting too unwieldy to be able to effectively distribute all the SDKs, binaries, whitepapers etc. that we want to hand out. Much of this content will be exclusive to the PDC – we just can’t distribute this quantity of content any other way.

So what are you waiting for? We’re filling up fast… don’t miss out on the chance to attend!

Get it from http://silverlight.net/GetStarted, along with the developer tools, documentation and the June update to Blend 2.5.

Lots of new goodies – as ever, Scott Guthrie’s blog has a comprehensive guide. I’m not going to try and compete with him today: my family tell me it’s time for the weekend to start!

If you’re looking for something to try out, there’s an updated version of Hard Rock’s Memorabilia site, but the really cool new site out there is a graphical adventure called Buddy Knavery, written in the style of old-school games like Zak McKracken and Maniac Mansion. I’ve already wasted far too much time playing with it instead of updating this blog post! There’s some amazing work here – hard to believe that it was all written by one guy in his spare time…

If you're into any of the technologies that this blog covers, you'll be mad if you miss the Professional Developers Conference this year. It's actually been three years since our last PDC, so we're overdue! I'm really excited about all the things we're going to be covering at the PDC this year: those of you who have attended the conference in the past will know that we only run a PDC when there is major news to share, and we've got some killer content this year. Registration opened yesterday, so now is a good time to get ahead of the crowd.

We keep most of the session titles under wraps until the event starts - this is a future-orientated conference, after all. But even from the session abstracts we've posted so far, you'll see sessions that cover the Live Mesh, Internet Explorer 8, Windows 7 (including details on how to program for the multi-touch feature we showed off this week at Walt Mossberg's D conference), as well as really hardcore deep-dive sessions on topics like the internals of the Silverlight rendering pipeline and our internal usage of Team Foundation Server.

But there's one other thing that has me salivating about the PDC as a WPF developer. Jaime Rodriguez (content owner for the pre-conference) has secured none other than Charles Petzold to deliver a one-day session on WPF. Charles Petzold! If you've been living on Mars for the last twenty years, Charles is a titan of the Windows programming world, having written several seminal titles, including no less than two books on WPF. Indeed, Jeff Atwood describes him as "the guy who put the h in hWnd". Charles is a hero of mine - he writes concisely, precisely, knowledgeably and articulately. I remember bringing a stack of copies of his first WPF book to a team meeting; the product architects were as eager to read his verdict on their platform as a Broadway theater director is to see the early papers after opening night.

Charles isn't one of those speakers who seems to be permanently on the conference circuit - in fact it's pretty rare that you get the chance to see him "live" at all, even though he delivers some amazing lectures when he does present. This is a unique opportunity that you just don't want to miss if you're building your mastery of WPF. Here's what Charles wrote for the pre-conference abstract:

This session will go deep into WPF and explain the infrastructure and services that WPF introduces. Begin with a solid foundation in dependency properties. Advance to the retained-mode graphics system and visuals. Explore the layout model, routed input events, and data binding. Discover control customization with styling and templates. Finish the day with an array of powerful graphics facilities, including animation and 3D. After attending this code-heavy, few-slides session you will have all the great insights needed to develop responsive and dynamic WPF applications that are easy to build and maintain.

One day of Charles talking about WPF - that's worth the conference admission price alone!

I haven't seen these training videos receive nearly the coverage they deserve, so I wanted to try and "bump" them onto the radar.

My erstwhile UK colleagues Mike Taulty and Mike Ormond have been hard at work over the last few weeks recording an amazing series of Silverlight 2 training screencasts. All free for the taking, these fifty videos provide a comprehensive guide to all matters Silverlight: from basic topics such as layout, controls, data binding, and styling to advanced topics like sockets, cross-domain requests, multi-threading and HTML interop. If even that's not enough, there are some great tips and tricks that go beyond the documentation: loading assemblies dynamically, embedding fonts and creating custom splash screens.

Many screencasts are too long or too ponderous - they don't suit the rapid-fire medium of the Internet. These are all short - mostly just a couple of minutes in length, and they're well edited to remove anything extraneous. Highly recommended - please produce some more, Mike and Mike!

Check them out here: http://www.silverlightscreencasts.com. Oh, and of course, you'll need Silverlight 2 Beta 1 to watch them!

Today I'm excited to announce the public beta availability of a major new release of WPF. Since we shipped .NET Framework 3.5 late last year, the team has been hard at work at a new release that adds many supplemental features, fixes a good number of bugs, offers many performance optimizations, and includes a new streamlined installer for a subset profile of the .NET Framework optimized for client scenarios. This new release will ship as part of .NET Framework 3.5 Service Pack 1 later this summer; the beta release is an early preview of these enhancements. In this blog post, I want to provide a broad overview of the new features in this release, focusing on WPF.

Deployment
It's been interesting over the last year or two to see the balance between business and consumer applications developed using WPF. Our early expectation was that WPF would be used primarily for consumer software: the assumption was that animation, rich media, flow documents, 2D and 3D graphics etc. would be primarily of interest to those kinds of applications. In fact, it's been surprising how many enterprise applications have taken advantage of it: architectural patterns such as the data templating and binding model and the separation of UI from code have turned out to be even more compelling reasons to adopt WPF in many cases.

Although Windows Vista includes WPF out of the box, we recognize the need to provide a lightweight way to deploy the platform to desktops running Windows XP. If you're distributing a consumer application over the Internet, it's key to have a setup package that downloads and installs quickly, while providing the user good feedback on its progress. We've put the .NET Framework on a diet, and we've now got a solution for those kinds of applications. As well as the full .NET Framework, we now have a Client Profile that weighs in at about 25MB (roughly the same size as Acrobat Reader), installs in a couple of minutes, and provides a customizable install experience.

How did we reduce the size of the .NET Framework? We removed many assemblies that aren't typically used in client application scenarios (it would be an esoteric client application that needed ASP.NET to execute locally, for instance). The file list was selected over the past year through profiling of numerous client applications; at a high level, it includes the core CLR and base class libraries, WPF, Windows Forms and WCF. We also took advantage of some new compression technology to shrink the package considerably. You can still target the full .NET Framework, of course - this is just an additional option. And it's important to note that the actual shipping assemblies are identical in both the Client Profile and the .NET Framework as a whole.

In Visual Studio 2008 SP1 (also in beta today), you can target the Client Profile through a checkbox in the setup project template. You'll of course get a warning during the build process if you have this option set and your project has a dependency on assemblies missing from the Client Profile. When you compile the application, you will have the option to package the Client Profile installer and your application together into a seamless, unified installer for the best possible experience. We provide a tiny (~200KB) bootstrapper package that keeps to an absolute minimum the time between an end-user clicking the installer and seeing results. We even do a full ngen on the .NET Framework files asynchronously during the install process, so that nothing competing with the startup of your application when it runs for the first time. Despite all this, you should expect to see the full setup complete in a matter of just a few minutes.

How does an application know if it has enough of the .NET Framework to execute? I'm glad you asked that question! Only applications that have been compiled to target the Client Profile will contain the special manifest that indicates that they are supported on machines with just the subset. If you try and execute an application that isn't appropriately marked, the Client Profile will pop up a dialog that will help the end-user update to the full framework. It's also important to note that the Client Profile is fully compatible with ClickOnce.

For end-users who have opted into Windows Update, the .NET Framework Client Profile will be upgraded to the full .NET Framework through a background drizzle process so that applications that target the full framework will be able to take advantage of the increased number of people with WPF installed on their machines.

Lastly, shortly after Visual Studio 2008 SP1 ships, we'll be releasing an add-in that will provide developers with the ability to completely customize the look and feel Client Profile installer - changing background graphics, etc. We're also working with third-party installers such as InstallShield to build Client Profile support into their setup packaging technologies.

One other deployment feature unrelated to the Client Profile - we've slightly loosened up the policy for managed executables run from a network share to allow them to run with full trust. This is a popularly requested change, as Brad Abrams' informal poll testified.

Graphics
The shipping .NET Framework 3.5 included a few powerful enhancements to the WPF graphics engine; in particular, the UIElement3D and Viewport2DVisual3D classes that provide support for fully interactive 2D elements on 3D surfaces. We also made substantial performance improvements to layered windows and fixed occasional animation stuttering issues. But we've gone way further with this release, adding a number of heavily-requested graphics features.

As demonstrated at MIX08, 3.5 SP1 adds support for HLSL shaders with the ShaderEffect class (see image to the right), allowing an almost unlimited range of visual effects to be applied to WPF content. Shaders are implemented entirely on the GPU (if you have Pixel Shader 2.0 support in hardware), or otherwise with an efficient software implementation - this means you can add wild effects like flares, lensing, distortions or blurs without adding a significant burden to the CPU.

You can target the properties of a shader effect with data binding or animation, allowing for even richer effects, and because WPF is a fully-integrated platform, any controls on which a shader effect is applied remain fully interactive.

If that wasn't sufficient, by the final release of .NET 3.5 SP1, we'll have support for even deeper DirectX integration. Essentially, any Direct3D surface can be used as a brush for WPF content through the new D3DImage class, enabling you to overlay or blend Direct3D content interchangeably with WPF content. You can use multiple D3DImage classes simultaneously, and because they are still rendered by DirectX, there is no major performance impact. You can even alpha-blend Direct3D content. If that wasn't enough, you can even take a Direct3D surface and apply it as a texture within a WPF 3D scene - mind-blowing! More information on these features is available at Greg Schechter's blog.

We've got a vastly improved WriteableBitmap class that enables efficient image manipulation. WriteableBitmap provides a bitmap image that is mapped to system memory, allowing you to change the contents and have it automatically render to the screen (taking advantage of the retained mode model in WPF). The original implementation of this class allocated a new bitmap with every frame update, making it pretty slow for most scenarios. The new replacement is fast, synchronized with UI changes and has constant memory usage, enabling tons of new scenarios in WPF - for instance, paint programs, fractal renderers, and software webcam output.

We've made some minor granularity improvements to the tiering APIs, for instance, enabling you to verify whether pixel shaders are supported in hardware. We've added nearest neighbor image sampling as a bitmap scaling mode. Last, but not least, we've finally fixed the most common bitmap effects in WPF - no longer are blur and drop shadow software-rendered: if you use the new blur and drop shadow API introduced in SP1, they'll be fully accelerated using the GPU. The legacy blur and drop shadow APIs have also been hardware-accelerated, providing immediate, huge improvements to performance for applications which make use of those capabilities.

Performance
As Ian Ellison-Taylor, the General Manager for WPF, is fond of saying, we're never done with performance. As with any high-end graphics platform, there are always optimizations that can be made. In this release, we've made major strides forward with performance and memory usage of WPF applications across the board. You'll notice these improvements regardless of whether you're targeting WPF 3.5 SP1 or an older version.

"Cold" startup of an application is one area where people are particularly sensitive to performance. There's a lot to be done at this point in time: assemblies need to be read in from disk, their manifests need to be checked for strong name verification, and any dependencies need to be loaded and checked also. As an application author, you can have a substantial impact on the startup of your application by being sensitive to this: you should load only what you need to display the initial screen and delay the load of other assemblies until they're needed. If you need Windows Forms to display a couple of forms buried within your application, don't put a dependency in the executable that's first loaded - it'll add a couple of seconds to your application startup. We've gone through the WPF assemblies and done a lot of optimization work to ensure that we get your first pixels on-screen as quickly as possible: by RTM, we think cold startup will be improved by up to 45% depending on application size and scenario. In general, the bigger the application, the more gain you'll see.

For XBAPs, we've switched to HTML for the initial loading screen, so that you immediately see progress when you click on an XBAP rather than being greeted with a rather confusing blank browser page for the first couple of seconds. There are also some additional cold-start improvements on top of those mentioned above for XBAP scenarios which give an additional 10% boost.

By RTM, we'll also have a "splash screen" support in Visual Studio 2008 SP1 to minimize the work in building applications that display an initial screen immediately, having a big impact on the perception of an application's responsiveness and reducing the risk of an end-user accidentally firing up two instances. You can either designate an image as a splash screen by marking a bitmap resource with a build action of SplashScreen, or supply your own fully customizable class based on our template that is loaded prior to the Application object during startup.

It's not just cold-start scenarios where we've been hard at work optimizing WPF. We now have container recycling for controls based on the VirtualizingStackPanel class (such as ListBox, ListView and TreeView). This is an opt-in feature (you have to set the VirtualizationMode attached property to enable it) due to some subtle semantic changes to these controls' behavior, but it can provide up to a 40% scroll performance improvement by reusing the UI elements that go out of view during scrolling wherever possible. We also now offer deferred scrolling as an option (similar to the way the Outlook inbox scrollbar works).

There are lots of other control virtualization optimizations too: TreeView now offers virtualization (perfect for an Explorer-like scenario), and columns can now be virtualized, making it much easier to build an efficient DataGrid control. And we've identified and fixed a few other performance "cliffs": improving some text rendering and frequent z-order manipulation issues.

New Controls
It's been a long time in coming, but we're finally adding the much-requested DataGrid control to WPF. This will ship out-of-band at first, just after we release 3.5 SP1; it will take advantage of the various virtualizing optimizations mentioned above so it should be relatively efficient, and of course, like all WPF controls, it will be possible to completely change the look and feel of the control through templates. We made a number of API enhancements to better support the DataGrid scenario: multi-selectors, null value auto-conversion, transactional item editing, alternating row support, item-level validation - and of course, all these are available to third-parties to improve their own high-end data grid controls.

Another oft-requested control is the Office Ribbon, and I'm sure you'll be pleased to know that we're also shipping an implementation of that control, also out-of-band, before the end of the year. The ribbon will be fully implemented in WPF, will be compliant with the UI design guidelines and have an intuitive collection-based API.

The third control does ship in-box with .NET Framework 3.5 SP1, and is a richly-functional WebBrowser control. Since the initial release, WPF has enabled web content to be displayed via the Frame element, but that had a number of limitations: you couldn't interact with the content of the frame programmatically, HTML content could only be hosted from a URL (not from an in-memory stream or string), you couldn't navigate programmatically through the history, and you couldn't interact with any JavaScript on the page. The WebBrowser control offers all those capabilities, enabling much more seamless interoperability between WPF and HTML content. It also provides a great way for WPF to host Silverlight content - just point it at the HTML file that hosts the Silverlight .XAP file. One other nice touch: it supports partial-trust mode for use within XBAPs, enabling an XBAP to include an inline frame of HTML content that can be interacted with. 

Other Enhancements
There's a number of other small but useful enhancements in this release that don't really fit under any of the above categories. We now support string formatting for data-bound text: this saves you having to write a class that implements IValueConverter just to do something as simple as formatting a number. We've done some work to both simplify and deepen support for LINQ to XML and LINQ to DataSet for data bound members. Lastly, we've extended our Firefox browser support beyond the XBAP capability in 3.5 by adding native support for ClickOnce (.application files).

The WPF designer in Visual Studio 2008 SP1 has also undergone a major overhaul. It's faster, for starters, and we've done a lot of work to support some of the more esoteric XAML edge cases that previously caused the editor problems. There's now an event tab in the properties tool-window, which delivers parity with Windows Forms for creating and viewing event handlers from the designer. One feature that I know will be particularly appreciated by a few folk who've harangued me over the past few months in our labs is support for XAML refactoring - something that was previously a rather painstaking and menial task. Finally, there's support for BAML runtime debugging, enabling you to catch errors that would otherwise be hard to pin down.

Conclusion
It may be a slightly awkward name, but .NET Framework 3.5 SP1 represents a major new revision of WPF that brings it squarely into the prime-time. I genuinely believe we've nailed all the most common criticisms of WPF as a desktop platform with this release: a much better deployment story, some amazing new graphics capabilities, across-the-board performance improvements, the three most commonly-requested controls, and an improved editor experience. When you add all this up together, you can see why this servicing release is such a significant step forward for WPF - it opens up new territory and shows the growing maturity of our strategic next-generation UI platform for Windows.

Right now, SP1 is a beta release; we plan to ship the final version later this summer. As with any beta release, there are always a bunch of caveats relating to quality, and I really want to emphasize those a little more strongly this time round. I do not recommend installing this beta release on your main development machine. Due to some complex build timing issues, this release is incompatible with Silverlight 2 Beta 1; it will, however be compatible with Beta 2 when it ships in a few weeks' time. There's also a glitch we discovered in late testing that can cause Blend to crash; a hotfix is available to the 2.5 preview release that fixes this, and we'll of course have a full solution in place prior to the final release of SP1. Lastly, if you're running Windows Vista, you should install Vista Service Pack 1 prior to installing Visual Studio 2008 SP1 Beta. Hey - if this was done, we'd ship it - that's why we call it a "beta"!

One last thing - although I've majored on the improvements to WPF itself, this service pack also contains enhancements to ASP.NET, ADO.NET, WCF and Team Foundation Server. For more details on these broader changes, Scott Guthrie's blog provides the best overview.

So where can you go to find out more about this release? If this blog post isn't enough, you should check out the "week of WPF" that starts today on Channel 9. For seven days in a row, we'll post a series of interviews with the core WPF team, talking and demonstrating the new enhancements in this release. Adam Kinney and I had a lot of fun filming these, and I think you'll enjoy them. In the first interview, I sit down for a chat with Ian Ellison-Taylor and Kevin Gjerstad about the philosophy behind this release and the long-term direction for WPF. Check it out!

Congratulations to Martin Grayson and team for building one of the smartest Silverlight 2 demonstrations I've seen to date. I saw parts of this demo a month ago when I was in the UK, and I'm delighted it's now released.

Whether or not you're involved in the healthcare sector, this demo does a great job of showing how Silverlight 2 can transform web-based application development. We're already starting to see many real-world applications using Silverlight 2, even in its beta 1 stage; I'll post a list of the best ones I've collected before the end of the week. With a beta 2 release not far away, momentum is continuing to grow. And keep an eye on this blog first thing Friday morning for a separate exciting announcement (he said elusively)...

I've posted a few times about issues relating to enterprise distribution of Silverlight, and I thought I'd mention one additional topic that came up during a customer tour that I've been on for the last ten days.

If you're a systems administrator, one of the aspects of Silverlight that concerns you is probably controlling the distribution of updates. In general, enterprises like to control their desktop and laptop environments to ensure no sudden surprises are caused (for example, by a runtime update that breaks a commonly used application). So some people may wish to dial down the update settings that are optimized for end-users when Silverlight is running in a corporate environment.

Silverlight supports enterprise rollout via WSUS and we provide guidance on how to roll it out across an enterprise via other means such as Group Policy (using the EXE-based installer). Silverlight is installed via a normal MSI plus an MSP-based patch which can be chained through a variety of means. Updating Silverlight to the latest revision can be done automatically or manually (by pushing out the latest MSP).

There are two different knobs an enterprise administrator can turn to control how updates are applied to the runtime:

• Firstly, if the enterprise sets the UpdateMode DWORD registry value under the HKLM\Software\Microsoft\Silverlight key to 2 then the Silverlight auto-updater will be disabled (i.e. it won't automatically check for updates or try to install them). This is the equivalent to an end-user choosing the Silverlight Configuration dialog and manually disabling auto-updates from the Updates tab.
• Second, the feature that allows a non-admin to patch Silverlight on Windows Vista without requiring admin elevation is not a Silverlight feature: it's a feature of Windows Installer which can be disabled if the admin wants to do so (and is indeed off-by-default in Windows Server 2008). You can switch this off using Group Policy by setting the DisableLUAPatching property. More information on UAC Patching can be found on MSDN.

If an enterprise disables the LUA patching feature in MSI and does not give their users administrative access to machines then users will not be able to install, remove or patch Silverlight. Only the enterprise administrator could touch the files. Obviously, it's important that someone is actively monitoring and distributing patches; as with any runtime for any operating system, without any means to fix potential security vulnerabilities, users' machines are at risk.

Many thanks to Bob Pomeroy for providing the technical detail behind this post. Hopefully this is helpful to those of you who need to persuade your IT department that Silverlight is "safe" for corporate adoption.

We released a minor maintenance update to Silverlight 1.0 over the weekend (internally known as GDR3, where GDR stands for "General Distribution Release"). I'm sure most readers of this blog already have Silverlight 2 Beta 1 installed on their own machines, but if you're building a site for the tens of millions of users that already have Silverlight installed on their machine, you'll be pleased to know that we're continuing to service the 1.0 release to take account of customer-reported issues.

The latest release is live now on the web for both Mac and PC; it reports itself as 1.0.30401.0 (where the build number indicates that it was compiled on April 1st). The changes are minor in nature and shouldn't affect existing applications; they include an audio bug fix for nForce 4 motherboards, an update to support custom parameters in ASX playlists, fixes to font support on Mac OS X Leopard and improved multi-language support during installation and update.

As ever, the way to check which version you're running is to right-click on some Silverlight content and choose the Silverlight Configuration context menu option; on a Macintosh, it's visible by browsing to the Silverlight run-time in its installation location in the browser Plug-Ins folder. Incidentally, it seems that most people don't realize that we publish release notes that highlight the deltas from one release to another (admittedly, the link is pretty buried, so it's worth adding to your favorites).

The jolly chaps at Conchango are setting up a user group in London to focus on Silverlight, and the first meeting is tomorrow! By chance I'm actually in the UK right now on something of a customer tour, so I plan to be there myself and give a bit of a status update on Silverlight 2 and WPF. Should be a fun evening - pizza and beer is provided, and the event kicks off at 6:30pm.

Full details and registration information are on the Facebook event site or on one of the Conchango blogs. If you're working in London, why not head over to London Bridge and come and say hi?

Just loved the team's latest Silverlight video. Props to Adam, Laura, Nic, Monica, Dan, Scott and Tina.

As many people will have noticed, we released Windows Vista Service Pack 1 this week (read about the notable changes here). Aside from the inevitable bug fixes and enhancements to support new hardware types, one of the underlying changes is that SP1 brings the Windows Vista and Windows Server 2008 codebases together.

This is a big deal, but it's surprising how few people have noted it: this is the first time we've ever had a common codebase for Windows that goes all the way from a budget consumer PC right up to a mainframe-class datacenter server. Internally to Microsoft, this makes it easier for us to provide sustained engineering on the product: if we want or need to update a system component, we only have to produce two binaries (x86 and x64) for all languages and product editions. Compare that to the days of Windows XP/2003, when we had maybe 25 different language editions and x86 and x64 variants for both client and server OS releases, and you can see how the testing matrix has become a lot simpler! Externally, the benefit is of course that simply by updating to SP1, you get the benefit of a kernel that has been through an extensive server-hardening process. (Check out this Channel 9 video I recorded last year with Eric Hanson to get just a small flavor of the stress testing work that we do with every build.)

Beyond the kernel and subsystem improvements, Windows Vista SP1 brings major improvements to IIS 7. Comparing the original Windows Vista "RTM" version against that shipped with SP1 is like comparing the basic and premium models of a car - the SP1 version of IIS contains all the features added to create the server-strength edition (with the caveat that Windows Vista SP1 is obviously not licensed for use as a commercial-scale production Internet web server). As a crude measure, compare the two screenshots of the administration console below - the left image is of Windows Vista RTM, the right is of SP1:

You'll see other changes to Windows Vista that affect certain relatively niche groups of developers. Direct3D receives a minor update to 10.1; there are new APIs to control the Data Execution Protection and Kernel Patch Protection features; and there are new cryptographic and random number generation algorithms available for developer use. As ever, more information about these features can be found in the Windows SDK.

As a .NET developer, you'll notice that Vista SP1 updates the installed .NET components to .NET Framework 3.0 Service Pack 1. The good news is that many of the enhancements from .NET Framework 3.5 are included in 3.0 SP1 - for example, of the list of fifteen enhancements to WPF described in this blog post, everything apart from System.AddIn and the Firefox XBAP support is included in Windows Vista SP1. This is a little bit confusing, but it probably helps to know that each of the last .NET Framework releases have built on top of each other, rather than existing side-by-side. The diagram to the right demonstrates this.

As a result, all the CLR and class library enhancements that were made to existing assemblies in 3.5 are incorporated in 3.0 SP1 (mscorlib.dll is updated from 2.0.50727.312 to 2.0.50727.1434); the binaries are identical to those shipped with .NET Framework 3.5. The only difference between 3.0 SP1 and 3.5 is that 3.0 SP1 doesn't have any of the new assemblies ("green bits") added in 3.5 for new capabilities like LINQ. Of course, if you've already installed .NET Framework 3.5 on your Windows Vista machine prior to installing SP1, you'll still have the full 3.5 release on your machine afterwards.

The many other nice features in SP1 for end-users and IT Professionals are outside of the scope of this entry, but suffice it to say that some of the major peeves have been addressed: UAC is less aggressive, file copy performance has been greatly improved (and it takes less time to "estimate"!), application compatibility is better, resuming from standby is faster, and over a thousand bugs have been fixed. For more detail on all these items, check out the main Windows Vista Service Pack 1 site.

It's worth noting in closing that many of the above fixes at least have been delivered via Windows Update over the last twelve months. We're moving away from the old-school approach where service packs were the main way that fixes were delivered to a more agile model where patches are available via Windows Update (or its enterprise equivalent, WSUS) and then rolled into a service update at a later stage. The goal is to reduce the gap between us fixing something and you seeing the results of that fix.

Well, what are you waiting for? Go install Windows Vista Service Pack 1!

Following on very nicely from my last post on deploying Silverlight content to your own production server, I'm pleased to announce that Silverlight Streaming has added full support for Silverlight 2 applications. As well as adding the basic support, the team have put a lot of work into simplifying the process of uploading and validating your application. Here's a basic walkthrough:

1. Create your Silverlight 2 application using Visual Studio or Expression Blend, do all the usual test / debug steps, etc.
2. Create a manifest file named manifest.xml, that describes how you want the control to be hosted. Here's a simple sample you can use as a template:

   <SilverlightApp>
     <version>2.0</version>
     <source>PopTheBubble.xap</source>
     <width>400</width>
     <height>300</height>
     <background>white</background>
     <isWindowless>false</isWindowless>
   </SilverlightApp>

3. Zip your application .xap and manifest.xml files together into one file.
4. Go to silverlight.live.com and upload the application.
5. You're done! Now you can embed the resulting content in any web page with an iframe or the sample code provided.

As a small example, here's a mini-game called PopTheBubble that you can learn to build by following the Silverlight 2 fundamentals hands-on lab. Click on as many bubbles as you can before the timer runs out - have fun!