Windows Phone application performance and optimization
9/16/11 from 12:30 PM to 1:30 PM
Room: Marriott Orange County 4

Here’s a link to the session page on C9.

The talk will cover:

• Performance counters and performance basics
• The new Windows Phone profiler
• Strategies for improving app performance
• General Q&A session at the end

Note to MIX 11 attendees: this talk is very similar to my MIX presentation, though the app is slightly different.

Hope to see you at the talk!

MIX 11 was a great success in my mind, as always it’s just a lot of fun to actually interact with everyone in the ecosystem, gather feedback, and sometimes even get praise for what we’re doing. We live in the Redmond echo chamber sometimes and it’s good to get out and see the “real world” (even if it is Las Vegas).

The kind of data we get

Once all the evaluations are together, the stellar event management staff compiles the results and we get a big Excel sheet with the data. I didn’t think it would be appropriate to post data from others, so here’s a look at just my entry.

The speaker metric is up to 4 (4 rocks), and the relevant material metric goes to 5.

The fields are:

• Date and Time,
• Session Code,
• Speaker,
• Title,
• Overall Satisfaction with the speaker’s presentation (to 4),
• Usefulness of the information presented (to 5),
• People in attendance,
• Evaluations turned in,
• % of people who turned in evaluations

You can also assume that attendance numbers drop a little on the last day (I was on day 3 of 3).

My results were in the top tier overall, an overall number of 3.89, a usefulness indicator of 5.00, attendance of 118, and turned in 9 (8%).

Oh, and the comments are always fun. In this case I’m pretty sure that one of my co-workers turned in the dreamy comment. But the others are useful. We get all verbatim feedback:

• Best session of the conference.
• AWESOME! This is exactly what I needed and I almost didn’t come because of the description.
• I can’t believe I got to see THE Jeff Wilcox. He’s soooo dreamy!
• Great session, I will use a lot of what I have learned.

How we use the feedback

It’s mostly interesting to check how speakers rank – you can assume that this plays into opportunities to give talks a few years in a row, etc. From a presentation standpoint, the other important metric is how relevant the material was to those that gave feedback.

Unfortunately the low number of forms – often hovering around 10% – doesn’t provide a ton of data. A lot like Yelp, we kind of assume we hear either about the best or the worst, but it would be very nice to have higher response rates to actually know how folks feel.

I’m sure event people also compare numbers between talk tracks, etc., but I just usually focus on my particular track. The Windows Phone track was short coded DVC.

Reading my own feedback, I should not have received a 5.00. Statistically somebody should have given a lower scale, I’m not that awesome. So this is a sign that the 8% turn-in rate is a little low; it would be better to have more data.

About paper vs electronic evals

I’ve heard that apparently paper return rate is much higher than electronic, but wow, 8% just hurts. When I attended a few European conferences last year (GOTO – formerly JAOO, and also Øredev), they also had paper evaluations – but much more simple (you didn’t even need a pen or pencil to complete). I loved the format.

When you exited the room of a talk, there would be three bins of paper: red, yellow, and green. You just take one and place it into the big box with the attendant – or if you want, you can write comments on the page as well.

I’m going to guess that they easily get more than a 50% response rate in terms of the basic “was it an OK talk or not?” feedback. Would love to see that format at MIX.

Please fill out those evaluations next time!

My Windows Phone app performance talk is now online, so check that out if you weren’t able to attend. I’ll be sharing the components I talked about pretty soon.

This year I decided to frame the discussion a little differently: we’ve talked about raw graphics performance, but for most apps, that’s not what developers are interested in touching. We’re all building list-based apps and those need to be best of breed.

The message I’m delivering is 3-fold:

• We’re doing work in ‘Mango’ (the next release of the Windows Phone) to improve performance by fixing bugs, optimizing, moving touch to its own thread, etc. Plus we’ve got that working set shrinking down (sweet!)
• You need to be doing work to optimize and simplify your apps. Reducing layout cost and the number of elements will give you the biggest bang for the buck.
• Perception of performance is as important as raw performance numbers. Consider what you can do here.

You can get the PowerPoint slide deck here and the talk is online at http://channel9.msdn.com/events/MIX/MIX11/DVC01.

Let me know what you think, Jeff.

MIX 2011 (April)

At Microsoft’s own MIX 11 conference in Vegas, I will be presenting on Windows Phone application performance (session DVC01), with an emphasis on lessons learned, what’s improving in the performance space, and a look at the new Windows Phone profiler.

I’ve had the honor of attending MIX several years now and each year it gets better, more refined, and remains an outliner in the Microsoft conference line-up (it’s more fun, casual, and Las Vegas is always fun).

You can see the current session list for MIX 2011 online. Also, the Silverlight Toolkit has been nominated for one of the Nineny awards, so that will be exciting! MIX is held in Las Vegas at the Mandalay Bay convention center April 12-14. The keynote speakers on day one are Scott Guthrie and Joe Belfiore.

NDC 2011 (June)

I’ll be presenting a few sessions on Windows Phone developer at the Norwegian Developers Conference (NDC 2011) in Oslo, Norway. The event is held from June 8-10. Here’s the current session lineup and schedule for NDC 2011. Scott Guthrie is giving the keynote on 6/8.

I’m presenting 2 talks:

• On the morning of 6/7, a talk on “Peeking at the source of a successful Windows Phone app”. This is a 300-level talk that looks into what it takes to have a large Windows Phone app, from dealing with the marketplace, solving common problems, and a look at a smart data caching and loading system for pulling down data from web services.
• In the afternoon, “Making a beautiful and rock-solid Windows Phone app”. This talk is more of a 200-level one that takes a simple Windows Phone app (like you could create in a matter of hours) and then takes it to the next level by adding visual effects, addressing usability and design issues, as well as adding error reporting and other key app services. It would be great for any developer thinking about building an app, to find out how to polish it and make a difference.

There are a ton of other great speakers going including Jon Skeet, Rob Conery, Jonas Follesø, and the .NET Rocks guys, just to name a few.

Hope to see you out in the wild this conference season!

Download the zip and make sure that you have the Windows Phone Development Tools and also the Silverlight for Windows Phone Toolkit.

This app has a number of things inside it:

• Simple view models
• Simple Flickr web service layer
• Integration of the service into the view model
• Navigation service passing parameters to pages
• Makes use of the JSON library on CodePlex
• Makes use of the Silverlight Toolkit for page transitions and the list picker control
• Various examples of templating and styling
• The Pivot control for the phone is used as a photo slide show with built-in flick and pan manipulations by not using the header or title properties, and binding the actual items to the photos to be shown
• PerformanceProgressBar

Things you need to do to get this working:

• You may need to add the references to the JSON library as well as the toolkit before it will build for you.
• You need a Flickr API key, get one here.
• You need to put your API key inside the FlickrService.cs file on line 23.
• Unless you want to browse all my photosets, you’ll want to put your own Flickr user ID string inside of MainPageViewModel.cs line 74.

The talks in the series will be uploaded in the coming weeks I’ve been told, but they are not yet available.

Pivot as a slide show component for photos

Since pivot has the nice manipulations support built into it, it was super simple to use as a slide show-style photo viewer. Here’s the XAML I used for the slide show page:

<controls:Pivot
    ItemsSource="{Binding Photos}">
    <controls:Pivot.HeaderTemplate>
        <DataTemplate>
            <Grid Height="1" Width="1"/>
        </DataTemplate>
    </controls:Pivot.HeaderTemplate>
    <controls:Pivot.ItemTemplate>
        <DataTemplate>
            <Image Source="{Binding ImageUrl}"
                    />
        </DataTemplate>
    </controls:Pivot.ItemTemplate>
    <controls:Pivot.ItemContainerStyle>
        <Style TargetType="controls:PivotItem">
            <Setter Property="Margin" Value="0"/>
            <Setter Property="Padding" Value="0"/>
        </Style>
    </controls:Pivot.ItemContainerStyle>
</controls:Pivot>

Walking through the elements, here is what they do.

ItemsSource binding

The view model for the slide show page includes a property that exposes the photo objects. This binds the pivot to that list. This means that without any of the other elements and templates being set, the pivot control will show the type name (Photo) instead of the actual photos.

Here’s the slide show view model file btw:

public class SlideshowViewModel : ViewModel
{
    private readonly IFlickrService _flickr;
    private bool _isLoading;
    private IEnumerable<Photo> _photos;

    public SlideshowViewModel()
        : this(new FlickrService())
    {
    }

    public SlideshowViewModel(IFlickrService flickrService)
    {
        _flickr = flickrService;
    }

    public bool IsLoading
    {
        get { return _isLoading; }
        private set
        {
            _isLoading = value;
            RaisePropertyChanged("IsLoading");
        }
    }

    public IEnumerable<Photo> Photos
    {
        get { return _photos; }
        set
        {
            _photos = value;
            RaisePropertyChanged("Photos");
        }
    }

    public void LoadPhotos(string photosetId)
    {
        IsLoading = true;
        _flickr.LoadPhotoset(photosetId, photos => Dispatch(() =>
            {
                if (photos != null)
                {
                    Photos = photos;
                }
                IsLoading = false;
            }));
    }
}

HeaderTemplate data template

This is a little bit of a Pivot control hack. You actually can set the header to x:Null, but then when you run this under the debugger, you may get a first-chance exception. The pivot control catches and continues, but it’s annoying as a developer.

This workaround, a 1×1 grid, enables a “screen capture” to be taken of the header, avoiding the exception when it isn’t of size:

<controls:Pivot.HeaderTemplate>
    <DataTemplate>
        <Grid Height="1" Width="1"/>
    </DataTemplate>
</controls:Pivot.HeaderTemplate>

This is all because for this slide show page, we don’t even want to show any headers, we aren’t using that visual part of the pivot ux – we’re just using the slick built-in manipulations logic and animations plus data binding.

ItemTemplate data template

This is what translates the data object (Photo) into an actual image that can be loaded.

<controls:Pivot.ItemTemplate>
    <DataTemplate>
        <Image Source="{Binding ImageUrl}"
                />
    </DataTemplate>
</controls:Pivot.ItemTemplate>

The binding to ImageUrl is for the property on the Photo data object. Sorry it was a string instead of a Uri, cheap and easy on my side I suppose.

namespace MyPhotoApp.Flickr
{
    public class Photo
    {
        public string Id { get; set; }
        public string Title { get; set; }
        public string ImageUrl { get; set; }
    }
}

So this way the image will automatically load. A nice improvement I should have made was write some better code to make sure the images are ready to go and maybe even fade in as they’re downloaded, but for a two-minute slide show, this was all pretty easy.

ItemContainerStyle for PivotItems

By default, the user experience guidelines for the pivot control and pivot items are nicely set in the default styles and templates. You’ll note without using the item container style that there is spacing between the edge of the photos and the edge of the phone’s screen.

This is the 12 pixel margin on the left and right of the pivot items; when using the standard phone styles for things like buttons and textblocks, which include another 12px margin, this means there should be 24px on the left and right of the actual visual things inside the pivot. Things align nicely in that situation.

But this is a photo viewer, so we actually want to show as much of the photos as possible – so this container style says “for each new item we are creating, let’s just set the margin and padding properties to 0!”.

<controls:Pivot.ItemContainerStyle>
    <Style TargetType="controls:PivotItem">
        <Setter Property="Margin" Value="0"/>
        <Setter Property="Padding" Value="0"/>
    </Style>
</controls:Pivot.ItemContainerStyle>

Navigation service usage

Inside this app, the navigation service is used to go to the slideshow page. Since the slideshow page has its nice view model data bound into the DataContext, I need to use the navigation service to get the photoset ID into the page. By using the URI inside the nav service instead of using a global variable or app-level call or property set, this means that the tombstoning for the app just works.

If you press the Start key while in a photoset, then hit back, you’ll come back to that photoset instead of the homepage for the app.

Now being a sample/demo app, I didn’t fully implement the right tombstoning behavior: I also should have actually stored the pivot selected index and restored that, so they would be on the same photo, etc. I also don’t using isolated storage in this app for simplicity sake, but that must be done for a real production app of course.

I also don’t properly do null/empty string checks in the calls, so if no photosets are returned and you try navigating, you’ll get a null ref exception. It’s demo code!

Moving to the sub-page

private void OnButtonClick(object sender, RoutedEventArgs e)
{
    NavigationService.Navigate(new Uri(
        string.Format(
        "/Views/SlideshowPage.xaml?id={0}",
        ((Photoset)SetList.SelectedItem).Id),
        UriKind.Relative));
}

Getting the photoset from the URI in the slideshow page

In the page’s OnNavigatedTo event handler, I read the property from the query string if I can. I only load photos if I find a photoset ID. This does have the trouble that you’ll see a blank bit of nothing if there are no photos returned.

Also if you look at the implementation, you’ll note that the loading automatically happens in the view model – so I don’t have to have the code in the slideshow file worry at all about whether to show the loading indicator or not. That’s all declaratively setup in XAML. Nice.

protected override void OnNavigatedTo(NavigationEventArgs e)
{
    base.OnNavigatedTo(e);

    var context = DataContext as SlideshowViewModel;
    if (context != null)
    {
        string id;
        if (NavigationContext.QueryString.TryGetValue("id", out id))
        {
            context.LoadPhotos(id);
        }
    }
}

And since all IDs in Flickr are to be treated as UTF8 strings, I don’t have to parse or convert the string value from the query string into an integer or anything like that.

General memory note

Note that you’ll want to watch your memory consumption if you go this route.

MyPhotoApp.zip download. Hope this helps.

Getting Started with Silverlight Development

Monday, 8/11, all day
Tim Heuer, Jeff Wilcox, and others
Firestarter session on Silverlight
Link

In this Firestarted themed session, Tim Heuer and Jeff Wilcox will give you the quick ramp up on creating Silverlight applications for the web, the desktop and the Windows Phone 7 platform. This day-long session will cover the basics of XAML, the programming model and how Silverlight differs from traditional .NET development.

The Developer Who Played With XAML: Silverlight code and fables

Wednesday, 10/11, .NET Track, 14:15-15:05
Jeff Wilcox
Link

Come hear about some of the history, a look ahead, and a tour of advanced Silverlight topics that should be intriguing to everyone and insightful to advanced Silverlight developers. Learn about why Silverlight has a native core, what AG_E_UNKNOWN_ERROR means, the importance of look-less controls (and how they differ from user controls), and what makes XAML rock. Learn about some of the great and not-so-great things that people do in their applications paired with recommendations and ideas for developers.

Whirlwind Tour of Silverlight and Windows Phone 7 – Part 1

Wednesday, 10/11, Smart Phone Track, 16:40-17:30
Tim Heuer
Link

With Windows Phone 7 launch happening, developers should be informed on how to build applications for the platform.  If you know Silverlight, you know how to write an application for Windows Phone!  This session will cover the core specifics of the Silverlight platform on the device and you’ll leave with some tips and tricks on creating the best experiences for your applications.

Exploring Windows Phone Development – Part 2

Thursday, 11/11, Smart Phone Track, 11:20-12:10
Jeff Wilcox
Link

Learn about intermediate Windows Phone concepts including the application lifecycle model, data binding, navigation system, and how to build the best app experience through 10 very useful tips.

Hope to see some of you there! Oh, and p.s., it ain’t dead.

Thank you for everyone who attended.

Original post before the talk

This week is the JAOO Conference in Aarhus, Denmark (Oct. 3-8), and I’m happy to be presenting on Monday 10/4 in the afternoon on Windows Phone 7 app dev. More information on my talk is available here, and the full line-up for Monday is here.

• Mobile Track
• 14:45 – 15:45
• Location: Filuren, Musikhuset

The talk will be a whirlwind adventure over the hour, so even if you aren’t familiar with the Silverlight development platform, you’ll still be able to learn plenty about the phone, the development story for apps, and what features and capabilities there are. And yes, I’ll even cover a few limitations and offer performance tips.

A very rough outline of the talk is:

• Introduction to Windows Phone 7
• About Silverlight for Windows Phone
• Controls
• Threading
• Navigation & Pages
• Specialized Controls
• Pivot
• Panorama
• Application Lifetime
• Launchers & Choosers
• Hardware APIs
• Performance
• Limitations
• Marketplace

I look forward to meeting everyone in Aarhus!

After the talk I will also be posting online the slides.

The session will be more comprehensive than the overview talk I presented at MIX 10 (which is available as a free online video stream now).

Click here to view the talk information on the Tech Ed site. The tentative information is as follows, but please double-check with the conference schedule builder before showing up:

Unit Testing in Microsoft Silverlight
Wednesday, June 9, 2010
11:45 AM – 1:00 PM
Room 287
Session Code WEB205
http://northamerica.msteched.com/topic/list?keyword=WEB205

Hope to see some friendly faces in the audience! I’ll be up there in some sort of speaker polo shirt uniform with khakis, apparently this conference isn’t quite as trendy and cool as MIX in Vegas .

If you’re going to be attending Tech Ed, I’d appreciate any early comments you have as there is still time to shape the content of the talk.

Peppermint-Demo.zip [Zip, 1.2 MB]

Silverlight:

Requires Visual Studio 2010 (or express)
Requires the Silverlight Toolkit
Requires the test framework binaries included in the zip

Windows Phone:

Requires the Windows Phone development tools CTP
Requires the test framework binaries included in the zip

An early preview set of bits are online at http://jeffatmix.com/ – and the next release of the Silverlight Toolkit when Silverlight 4 ships will contain support for the phone officially. Stay tuned for more.

Over the next few weeks, I’ll be blogging plenty on these subjects.

UNIT TESTING SILVERLIGHT AND WINDOWS PHONE APPLICATIONS
Jeff Wilcox in Lagoon B (Mandalay Bay)
Tuesday, March 16, 2010 2:05 PM (30 minutes)

Session materials, slides and code will be posted after the session at http://jeffatmix.com/.

Synposis from http://live.visitmix.com/MIX10/Sessions/CL59:

Learn how to create and maintain Silverlight and Windows Phone 7 Series applications using the Silverlight Unit Test Framework. See what tools are available to easily validate controls and application interfaces, add automatic testing to builds, and gain a solid understanding of test principles to deliver great experiences for your clients and customers.

What’ll be new at MIX for testing?

• Support for testing those Windows Phone 7 Series apps!
• New release of the Silverlight Unit Test Framework, with a modern user interface, Out of Browser support, and more.

Hope to see you all in Vegas! And if not – these sessions always make it online super quick. Let me know if there’s anything in particular you want covered in the talk.

More on David Anson’s blog post about the WPF charting components.

I really would like to thank each and every person who’s been able to use the tool. I really appreciate the feedback and conversations many of us have had to work to make improvements over the years (Wow, has it been so long?!).

What’s this all about?

Each year, Microsoft holds an Engineering Forum, jam-packed with sessions and talks much like an industry conference, focusing on everything from the core engineering disciplines to trustworthy computing and everything inbetween.

During the forum, a select set of awards are given out to a select innovations, recognizing teams and individuals for their successful engineering feats helping the company to ship safer, quicker, and better all-around software to the world. The criteria is challenging, nomination count very high, and the selection process intense.

Although the test framework wasn’t selected as a finalist, it did receive honorable mention, which is enough to make me happy.

It was also great hearing a little bit from some of the senior engineering leaders inside the company, including Ray Ozzie and Jon DeVaan.

A lot of great tools, processes, and accomplishments have been recognized over the years, and the bar is high, with great tools like Script#, Nikhil Kothari’s famous C#/JavaScript tool, as well as Brad, Krzysztof, and Michael’s FxCop (now built into Visual Studio).

I hope that, with some of the plans I have in place for the framework, that maybe someday it’ll be a finalist for a future award of this nature – there’s a nice shiny crystal award that would look great on the bookshelf!

What’s the Silverlight Unit Test Framework?

The Silverlight Unit Test Framework is a simple unit and functional test system specially designed for Silverlight, building on existing desktop unit testing knowledge and metadata. You’ll find the test framework inside of the Silverlight Toolkit’s source code package, and in use in a lot of places.

Thanks for everyone helping to make this a success!

It demonstrates simple concepts for linking files from a Silverlight to WPF project, using partial classes and partial methods, preprocessor directives, and other tools to create projects that work throughout the Microsoft Client Platform.

Silverlight sample application

WPF sample application -100% the same source

Download the samples – Zip, 596 KB
The Zip contains the following work:

• Toolbar control for Silverlight and WPF
• Sample application for the Toolbox
• Continuum application – same XAML and CS shared between a Silverlight and WPF application that uses the DataGrid, charting controls, and our custom Toolbar control
• Value-add code, Awesome.cs, that adds some simple functionality to the WPF application only

Hope this helps.

This provides a very nice experience when using Visual Studio 2008 and Expression Blend 3, since the Toolkit’s controls appear alongside all other Silverlight SDK controls now.

I wanted to take a few minutes and record a few questions and answers about the new experience. Let me know if there are some other questions you’d like answered.

Why are there two setup downloads for the March 2009 release?

The March 2009 release is available for targeting Silverlight 2 applications (recommended for most developers and designers working on current production Silverlight 2 apps), and a Silverlight 3 Beta release.

Since the target platform is important, you can make a choice. Of course, both the Silverlight 2 and Silverlight 3 Beta installs for the Silverlight Toolkit support side-by-side; however, the Visual Studio 2008′s Silverlight Tools do not support “multi-targeting,” so you really should decide and stick to a single target development environment for Silverlight coding today.

What are the system requirements?

The Silverlight Toolkit only requires a recent version of the .NET framework to install. However, for the best experience, you should have one of these development environments installed and configured:

• Visual Studio 2008 SP1 with the Silverlight Tools (Silverlight 2 or Silverlight 3 Beta)
• Visual Web Developer Express with the Silverlight Tools (Silverlight 2 or Silverlight 3 Beta)
• Expression Blend 2 SP1 with Silverlight 2
• Expression Blend 3 MIX ’09 Preview with Silverlight 3 Beta

More information about these tools and downloads is available at http://silverlight.net/getstarted/silverlight3/default.aspx.

You can install the Silverlight Toolkit before or after the Silverlight Tools installation.

What’s with the namespace change to System.Windows.Controls?

As the Silverlight Toolkit has begun delivering controls into the official Silverlight SDK, it became apparent that we should be consistent across the Silverlight platform with regard to the namespace used for the Microsoft controls. As a result, we decided to make this namespace change along with the new “.Toolkit” assembly name scheme.

Where’s the AutoCompleteBox control? How about TreeView?

Some of the “Stable” controls were moved to the official Microsoft Silverlight 3 Beta SDK, since they are trending towards the “Mature” quality band. As a result, the controls live in different assemblies depending on whether you are performing Silverlight 2 or Silverlight 3 Beta development.

In the Silverlight 2 Toolkit March 2009 release, AutoCompleteBox is in System.Windows.Controls.Input.Toolkit. TreeView is in System.Windows.Controls.Toolkit.

In the Silverlight 3 Toolkit March 2009 release, AutoCompleteBox is in System.Windows.Controls.Input. TreeView is in System.Windows.Controls. These assemblies are part of the Silverlight 3 Beta SDK and DO NOT require installation of the Silverlight Toolkit.

The Silverlight 2 controls are compatible with Silverlight 3, so existing applications will continue to work – but we do highly recommend that you update to the appropriate Silverlight Toolkit for your target Silverlight version, since we do add version-enhanced features, such as animation easing for the Silverlight Toolkit charts in the Silverlight 3 Beta.

More information about the assembly and namespace name changes is available in this post by Shawn Burke.

What is installed with the Silverlight Toolkit now?

You’ll find the same basics as before, plus some. You’ll find these in the “Microsoft Silverlight 3 Toolkit March 2009″ (or similarly named folder for the Silverlight 2 version) folder in your Start Menu.

• New “Welcome” page with general information about the release, plus a link to the breaking changes and release notes for the release.
• Links to the CodePlex site for the Toolkit, plus the Silverlight.net discussion forums
• A link to the sample application for the Toolkit, served from the local system
• Links to Zip files containing the control source code and/or the sample source code
• The documentation for the Toolkit controls in CHM format. The documentation file no longer requires the “Unlock” workaround step on Windows Vista and Windows 7. Do note that the documentation for former Silverlight Toolkit controls that now appear in the Silverlight 3 SDK, such as AutoCompleteBox, are now located in the official Silverlight documentation. An offline download of the SDK documentation is also available.

What rocked about the Zip?

Well, in my mind, it was:

• Transparent experience
• Nothing fancy
• Lightweight. Nothing to install, so if you didn’t want it anymore, you could just delete the files, for instance.

What was so bad about the Zip?

• No integration into Visual Studio or Expression Blend out-of-the-box, without doing some manual file copy or registry work
• Confusing to users used to a setup experience
• CHM documentation files downloaded in a Zip require “Unlocking” before they work. Until then, they appear broken.

Would you consider offering releases in a Zip file, optionally, still?

We’re open to the idea. Especially now that there’s an Eclipse Silverlight development experience, we do need to be mindful of the need to use the releases on other platforms.

Since our packaging infrastructure was initially designed to output these nice .Zip files, it wouldn’t be too tough for us to get this going. We’ll see what the customer requests look like.

How do I select whether I want to get the source code to the controls?

There is an installation option for a feature called “Source code,” you can click on the box to the left of the item and remove the component if you would not like to install the source package.

If you do select this feature (per the default), a .Zip file is placed on the system that contains the source code. You can extract the zip file into a location of your selection to build or view the source.

As always, the source is also available on the Silverlight Toolkit CodePlex site.

What about Microsoft Expression Blend integration?

The Blend 3 MIX09 Preview release includes support for having the Silverlight Toolkit appear in the “Custom Controls” tab of the Asset Library. This is only available for Silverlight 3 Beta, not the Silverlight 2 / Expression Blend 2 product.

There is some really great design time support in this release. For instance, if you just drop a “Chart” control onto your Blend design canvas, you’re greeted with a chart that has simple design time data! It might look a little like one of those “the most bars anywhere” cell phone commercials, but it is very helpful for styling.

What powers the installer?

We leveraged the open source Windows Installer XML (WiX) toolset, an excellent and easy way to build Windows Installer packages. Kudos to Eric St. John, a Microsoft developer who contributes to WiX, for excellent advice, btw!

This was important to our small development team, since we wanted to spend time working on new features like awesome design-time integration and new controls like accordion instead of assigning a developer to the setup full-time.

Hope you like the new experience. Let us know!