Amit Chatterjee's Blog

Submitting the Windows Phone application to the Marketplace

2011-07-30T07:52:08Z

The last several weeks have been quite busy at work. However, I finally found the time to publish my application to the market place and it now now live there, with a few downloads reported too! In this post I will walk you through the steps involved in submissions, and share with you my experience.

Registering at the App Hub

Before you can submit an app to the market place, you first need to register for “App Hub” membership. You do this by going to http://create.msdn.com. This essentially is a vibrant community of app and game developers for both Windows Phone and XBOX live games. The hub provides free tools, information, and the community you need to create and publish beautiful apps and games that reach every Windows Phone user and XBOX live members worldwide. Here’s how the home screen looks before you sign up

You first need to register for an annual subscription of $99 USD that gives you the following privileges for both the world of phone apps and XBOX.

The registration itself is a 5 step process as noted below and is quite simple. I show some of the screens below as well

Once signed up, the App Hub home screen now looks like the following. Notice the advertisement for the next version of Windows Phone, code named Mango! I can’t wait to upgrade my phone, and have been waiting to finish this tutorial and getting my application published!. My next app will be on Mango!

Also notice that the action on the App Hub are different now – for example, you get the option of “Submitting for Windows Phone”

The App Submission flow

The following diagram captures the flow involved in the app submission process

We have of course so far been focusing on the first step of the process – creating the application in Visual Studio. I have also been developing using the Emulator. Before submitting the application it is of course also very important to test on an actual device. To do this however you will need to “Unlock” the phone. To do this, connect a phone device to your laptop using the USB (charging) cable, and the run the “Windows Phone Developer Registration” application from the Windows Start menu (this application gets installed on your system when you download the phone development tool kit). The application looks like the following – it takes in your Live ID and then “Unlocks” the phone device so that Visual Studio can deploy the phone application binary directly onto the phone device.

In Visual Studio you can select the “Windows Phone 7 Device” as the target for the publishing as shown in the Visual Studio Menu bar below. Now when you build and publish, the application will be deployed on the device and you can do your pre-certification device testing there. The application of course worked well for me there.

The Certification Process

The certification process is of course the most important part of the submission. The goal is to ensure that before any application or game is taken into the market place, it is certified that the application is reliable, it makes efficient use of device resources, the do not adversely interfere with the device functionality, and that they are free of any malicious software.

The full certification and submission process is as outlined below.

The flow through the certification process

The following screen shots show the flow, as I proceeded with each step of the certification process.

The submission process starts with the “Upload” step where you select the name of the application, give it a version number, and point to the .XAP file in the bin\release directory where Visual Studio builds the application. Note that the entire application is contained in single binary manifest file of extension XAP. This is shown below.

On hitting next on this screen, the submission process found one error – that my application did not have the locale information marked correctly. At this point I had to add the following lines to the MainPage.xaml.cs to mark the locale as “English”, recompile the application to regenerate the XAP file, test it, and redo the application submission process.

The next step is to describe the application by providing information that will later show up in the application market place.

This information will help potential buyers decide whether they want to try or buy your application or not. Here you choose to describe the category that best describes what the application does, a detailed description, and also key words that will lead an application search to your application. This essentially is your “marketing” collateral for your app.

As part of this step, you are also needed to provide various icons and art work that are used in various places in the market place. Here note that the Large Mobile Tile app is really a mandatory image (as I would learn later) though it is not marked as such. This icon is used when you pin your application to the start page. Likewise the “Background Art” image is mandatory too – it will be used when your application shows up in the market place. You can also submit a set of screen shots for the application and these will further describe and “market” your app when listed in the market place. The most convenient place to capture the screenshots of course is when you test your application on the Emulator. You can use the Windows Snipping tool to capture the screen shots – however, be sure to avoid including any of the Emulator “chrome” in the screen shot – this too I found out later.

The next step is to select the price for your application, and also decide which market placed the app would be listed in. There are three different geographical regions as you see in the image below. Select carefully and check out the defaults – or your application may not show up in the right marketplaces. (Note, each phone user provides a Live ID when they configure their phone for us. The country the Live ID is associated with then becomes the default market place for the “Marketplace” application on the phone.

The next step is to call out a set of testing instructions that will be carried out in the “backend” to make a final validation that the application works as designed. You can also select the publishing option – for example, you can select that the app be published as soon as the validation and certification is done, without any further interventions from you.

The last step then is to click the “Submit” button and submit the application.

You can track the state of the submission on the “My Dashboard” page at “App Hub”. For example, a couple of days later I noticed that my submission had run into issues.

As shown above, the certification had run into errors, and clicking on the “View Error” page leads you to a PDF file with details about the errors. The PDF files looked as follows

In my case all of the errors were related to the images and iconography. I was missing the large mobile tile app, and the background art image, and the application screenshot included the chrome of the Emulator. Also, it called out that one of the icons in my application was still the generic Windows Sunburst icon. I then proceeded to fix the errors and in the process created my own custom icon and images (using Microsoft Paint, and saving them as .PNG files of the different dimensions necessary, as called out in the submission process).

I also had to select the “United States” market place, as apparently in the last submission I had not selected it.

The submission goes through

This time the submission went through without errors – a couple of days later, it was nice to see on the “Dashboard” that the process had worked, the app was in the Marketplace and it showed there were a few downloads too. The dashboard provides you several reports and statistics of your application.

The App shows up in the Marketplace

It was exciting to then checkout the Marketplace on my phone, search for “AmitC”, and have the app show up – and I could install it from there! To capture an image of the app in the market place, I launched the Zune application and searched for the app there – and there it was!

It felt great to build, blog, and publish about this simple Windows Phone application. I hope it has spurred some of the readers to write and publish your own application. I really liked the Visual Studio tooling experience and felt proud of my team which has developed this tooling!

On now to the Mango version of Windows Phone!

Cheers!

Unit Testing the Windows Phone 7 applications

2011-06-26T09:21:00Z

It’s been a long while since my last blog post. With some additional responsibilities at work, and a long trip to the US, I just did not find the time to update the blog with the latest developments. But I am happy to find time this weekend to bring the Chronometer Windows Phone 7 application to a logical closure. In this post I will also concentrate on the topic of unit testing windows phone applications.

A functional change first – clearing the history

However, before I get to unit testing, I would like to add a small feature to the application. This is about clearing the history of the events that get displayed in the Stopwatch page. I do this by adding a “Clear History” menu item to the AppBar and then add a handler for the menu item to do the job.

Here is the change in the XAML to add the menu item – notice the new ApplicationBar.MenuItem – the auto-completion intellisense feature when editing the XAML directly makes is very easy to add these UI elements.

The code for the click handler looks as follows:

The screens below capture how the menu item shows up, and (on clicking) clears up the event list history captured till that point.

Using Jeff Wilcox’s unit testing framework …

For unit testing Windows Phone (and other Silverlight) applications, I recommend using Jeff Wilcox’s framework for unit testing. I highly recommend you watch Jeff’s MIX10 session on this topic from this link. There are some limitations in the here – for example, you cannot unit test controls in the AppBar – but this is a pretty nice framework, and served my purpose of unit testing the application.

Jeff Wilcox’s blog explains the framework and you can also use this link to download the bits needed from the bottom of his blog page. Another useful link that helped me in setting up the framework was this Cheat Sheet.

As explained in the cheat sheet, I add a new Windows Phone project to the solution called WP7ChronomterUT, add a dll folder where I download the unit testing framework (and unblock the files), add references to the two dlls there, and create a new file call MainPageUT.cs where I will add the unit test. I also add a reference to the WP7Chronometer project. Below is a snapshot of how the new project looks – observe the references added.

Few more housekeeping things …

I need to do a few more things before I get to the unit testing.

First, I move the TimeSpanPicker1 style definition from app.xaml (application scope) to MainPage.xaml (main page scope). Please note that this needs to be included in the <phone:PhoneApplicationPage.Resources> section and that entire section needs to be ahead of the Grid definition in MainPage.XAML. This scope change is being done to avoid some limitations of the unit testing framework.

Second, we need to add a reference to the Coding4Fun.Phone.Controls.Toolkit that we installed via NuGet, to the new unit test project. To do this, you simply click on “Add Library Package Manager Reference” option for adding a new reference, and simply “install” the reference for the above toolkit from the list presented (note, the toolkit will already be listed there since we have installed is as part of the solution).

Third, I need to allow the unit test project access to the internal UI elements in the main application. To allow this, I add the following line at the end of the AssemblyInfo.cs file under ‘Properties’ node of the WP7Chronometer project (the main application)

Launching the unit test framework …

Since the project we are working on is specifically for unit testing, I would like “application” in this case to straightaway launch the unit testing framework and run the unit tests that I will write. To do this, I add the following code to the MainPage.xaml.cs file:

The above code instantiates the unit test framework, sets the root visual of the page to it (that is, what ever it will display), and also hooks up the back button to allow you to return back from drilling into test results.

Note, I also hide the system tray, otherwise it will hide the top of the test results screen.

I have also changed the page title and the application title in the MainPage.xaml file as follows:

Now we can write the actual unit tests …

The framework, once launched as above, will look for a TestClass and TestMethods in the dll as is normal for unit testing. Below I have a set of simple unit tests written up, to verify some of the initial states of the Chronometer application

The code above is pretty self-explanatory, and we are now ready to run the tests

Running the unit tests …

Simply set the WP7ChoronometerUT project as the start up project in the solution, build the solution, and launch it. The unit test framework loads, based on the above start up code, and presents the initial page of instructions as shown on the left below. It allows you the option of choosing the set of tests you want to run via tags (and gives instructions on how the tags work), and also counts down five seconds to choose the default option of running all tests. The screen on the right shows that all of the tests have been run, and all have passed (the green bar at the top). Also note the statistics at the bottom where it says 5 out 5 tests have passed (BTW, to allow this display to come through we disabled the SystemTray earlier).

You can drill down into the tests by clicking on the name MainPageUT (which is the file which has the tests), and you see the lists of tests in that set on the screen below left. You can drill down into each of the tests – for example, clicking on the “CheckifTimerDisplayisZero” shows the screen on the bottom left. It tells you more information about the test, including pass/fail status, and start/end/duration for that test. Also notice that the back button on the phone allows you to navigate back to the previous screen.

Just to give you a sense of how failing tests get reported, I can deliberately make one of the tests fails – for example, changing the Assert.AreEqual in the ‘CheckifTimerDisplayisZero” to Assert.AreNotEqual, and then on building and running the application you get the screens below. The framework calls out the overall status as fail, calls out the test that has failed, and allows you to drill down into why it has failed.

This is all pretty neat! It felt great to experiment with the unit test framework for the phone!

I am almost done with this set of blogs – what remains is to create an account in the marketplace and actually deploy the app! I will come back shortly with that.

Cheers!

Visual Studio ALM vNext announced at TechEd 2011, Atlanta

2011-05-18T11:52:58Z

I am very excited – we just announced the vision for Application Life Cycle Management (ALM) in the next version of Visual Studio, at TechEd 2011 North America, at Atlanta. In his key note address on May 16, Jason Zander shared the vision and the roadmap, and demonstrated some of the cool features you can expect in that release.

As you know, we have been working on great tooling for ALM since 2005, and the last big release was Visual Studio 2010, released in April 2010. The next release that we are working on will continue to build on the strength of the past releases. Our tooling encompasses the entire lifecycle for application development, as shown in the graphic below

With each release, our focus has been on reducing the major sources of failure and waste in the lifecycle. Continuing on that journey, we have major investments in TFS, Test, and advanced tooling coming in the next version. Jason showcased some of these in his keynote at TechEd 2011 Atlanta – please read his blog post on the vNext announcement. We have also put together a whitepaper which provides a great overview of the motivation for vNext and captures some of the highlights and screenshots!

We are continuing to refine the experiences that Jason talked about, and I look forward to writing more about vNext soon!

Cheers!

Building Windows Phone 7 User Interface with Expression Blend

2011-05-11T12:44:59Z

Microsoft Expression Blend is a great tool for designing user interfaces. Expression Blend 4 for Windows Phone provides a streamlined development workflow for Windows Phone 7 applications that was previously available for Silverlight and .NET applications only. You can refer to this link to figure out the version of the tool that best suits your purpose, including the option of the free version that is part of the Windows Phone 7 developer toolkit.

I have used Expressions Blend in couple of places in the Chronometer application that I have been building. You will find a series of blog posts on the topic, starting here. I find that Blend is a great way to get the styles for the user interface controls just right – rather than simply using the properties of the control, or hand coding the XAML. For example, in the last post, I had introduced the TimeSpanPicker control for the countdown timer feature of the application. The heart of the control is a TextBox control for the input of the initial value of the timer. If you remember, the default definition, and the default look of the control looked as below:

To make the display of the control consistent with the Stopwatch control, I need to change the background color to black, the font to Courier New, font size to 64, and font color to yellow. I could set most of these properties from the properties toolbox of the control in Visual Studio. However, the font size simply would not take effect. This is likely a bug in the phone toolkit, and I will look into it later. However, this led me to Expression Blend, and I found that you can create user interface styling in a really effective manner in there!

To use Expression Blend for designing the UI, simply right click on the MainPage.xaml file and click the “Open in Expression Blend …” menu as shown below.

This launches Blend in the full design mode for the xaml, as shown below.

You can then navigate to the control you want, by expanding the Objects hierarchy in the bottom left of the tool. Below, I have navigated to the TimeSpanPicker control and have selected it. You can now see the properties of the control in the tool.

Right click on the control, select “Edit Template” and then “Edit a Copy…”, as shown below

Note that in the dialog box on the right you have two options – to define a new style in the context of the application, or just for the page in question. This determines whether the style definition will go into the App.xaml file or in the MainPage.xaml file. I would really like to define the style so that it is available for the entire application, so I will select the “Application” radio button as shown below.

Notice above that the Object hierarchy on the left now shows the components of the TimeSpanPicker control, and I have selected the DateTimeButton control to really select the specific control I want to change properties of. At this point, the properties palette on the right hand side makes it really easy to change the properties. In the screen below I show how I have changed the font to “Courier New” and the size to “48 points”. (I needed to resize the control size to accommodate the larger size).

Next, I change the text foreground to yellow. For this I select the “Foreground” field in the “Brushes” section at the top right of Blend, and then click the little square button next to “foreground”, select “Custom Expressions” and type “yellow” as shown below. As you see, the text changes to yellow.

To change the background, I click the button next to “Background” and this time I choose “System Resource” and then select “PhoneBackroundBrush” to ensure that the background of the control will match the background of the phone. At this point the control looks exactly the way I wanted it to be!

That’s all we needed to do in Expression Blend. We simply hit “File.Save All” in Expression Blend and exit out of Blend. You will now get a pop-up i informing you that the xaml file was edited outside of Visual Studio, as shown below. We will of course accept this change by clicking “Yes to All”.

Notice that the designer in Visual Studio immediately displays the control in the new style.

Also, notice that the definition of the TimeSpanPicker control has also been automatically changed to reference the new static resource TimeSpanPickerStyle1 that we had created in Expression Blend!

If you remember, we had chosen to define the new style in the context of the full application. Hence the definition of the above new style is automatically incorporated in the App.xaml file – as shown below

That’s all. We now compile the application and a quick test shows that the timer functionality is working just fine, and the count down timer display shows correctly, and in the intended style, in both portrait and landscape modes

Expression Blend is very powerful designer tool, and it was fun dabbling with it a bit in building the Windows Phone 7 application!

Cheers!

Extending the Chronometer Windows Phone 7 app – introducing NuGet, Pivot, and the TimeSpanPicker control!

2011-05-01T14:19:25Z

I am back to coding this weekend, and would like to add a second feature to the Chronometer application – a countdown timer. You will remember that I started building the application a few weekends back, and you will find the opening post here. I have since added a series of posts that has introduced different concepts and evolved the app – you can find those posts on my blog as well.

The concept of the Timer is of course very simple – you put in a text box with a value of hour : minute : second, and then put in some logic to change the values, and count it down to zero. However, I was looking for a control that would allow me to edit the countdown value with a nice experience – like you get when you set the alarm on the Windows phone 7!. I looked around, and found that there is control built by the community – called the TimeSpanPicker – which has the exact functionality I need. However, I would need to load the package, copy down the files, get any dependent packages (if any), add references to my project – and that is a lot of work!

This then provided me the opportunity to talk about the NuGet extension to Visual Studio. NuGet is a beautiful thing! You can read more about it here. It solves exactly the problem I have alluded to above, and I simply include an excerpt from the above link that explains the basic functionality.

Let’s install the Library Package Manager (NuGet) extension. Click Tools and the Extension Manager – you can see below the packages I currently have installed.

Now, click the Online Gallery tab. Visual Studio now searches the gallery and presents a list of packages, based on their ranking (the community rates the packages). The view on my system is displayed below, and you notice that the NuGet Package Manager is already listed at the top, with a 5-star rating from 70 voters!

Simply click on the Download button to download and install the NuGet Package Manager package. It will download and install (once you accept the license agreement). After the installation you will be prompted to restart Visual Studio. If you now get back to the Extension Manager, you can see that the NuGet Package Manager is now installed.

Now we want to install the WP7 TimeSpanPicker control. For this, we go to the Tool, Library Package Manager, Add Library Package Reference option, and then select the Online tab to be able to pick from a list of packages out there. In the Search box now type “TimeSpan”. I got the following search results

I select the second one in the list (where the description says – “Just the timespan selector …”).

That’s all! The NuGet Package manager now downloads the package and adds references to the control into our project automatically, making it very simple to use the package.

I can now add the following line to the MainPage.xaml file to use the control in my layout – notice the last line in the xaml snippet below

Adding a Countdown timer to the Chronometer

We will now add a Countdown timer to the Chronometer. The way I want this to work is that the Stopwatch will still be the default functionality. However, I would like to slide the Stopwatch page out and get a new “page” where I will have a countdown timer functionality – that is, a control where I can set a time duration (hh : mm : ss), allow the user to start the timer, and then count it down to 00 : 00 : 00 and sound an alert.

Introducing a Pivot Control, and making the Stopwatch a PivotItem

Once I add the Countdown timer, the Chronometer application will have two discrete features – the Stopwatch and the Countdown timer. On the Windows Phone 7, we have two different controls – the Pivot Control and the Panorama Control – that will allow me to arrange these two discrete features horizontally in a virtual space that is several times wider than the width of the phone. I can then move through the controls – and hence the two feature areas – by simply sweeping the application surface with the fingers. Each control allows you to have a collection of items called PivotItem and PanoramaItem, respectively, to define the discrete feature areas

I will use the Pivot control rather than the Panorama control for two specific reasons:

The Pivot control sweeps each control completely to the next, where as the Panorama allows the items to overlap on the display as they sweep them in. For this application, allowing each of the features the full viewing surface will give a better user experience
More importantly, the Panorama control does not allow the Application Bar (at least, that is my understanding at this time), and I want that functionality. In fact, I will let each of the two features to have their own Application Bar

So far, the structure of the MainPage.xaml file looks like the following – with the fully expanded tree of controls shown on the right

I will now introduce the Pivot Control and Pivot Items, and move the earlier definition of the Stopwatch Layout inside it. This is done, by adding the following xaml code for the Pivot control and the PivotItem

Note, that the name of the Pivot control has been set as the Name of the Application, and the PivotItem has the name of the first feature – the Stopwatch. The rest of the original layout of the Stopwatch feature is now included within the PivotItem definition, and the definition is then closed off with the following tags. (The only other change I did was to move the Stopwatch display time TextBlock control a bit to the left, as it had gotten moved because of the above embedding)

Also, as the application will have one of two ApplicationBar controls, I am moving the definition of ApplicationBar items into a resource block as shown below, and will programmatically select the one that is the right one for the context. This is done by the following xaml code snippet

With this, the definition of the layout now looks as follow – contrast that with the one shown above.

Also, since we will now explicitly need to set the ApplicationBar. To do this, we first create a handler for the SelectionChanged event of the Pivot control. The code that sets the event handler and the code for the handler is shown below.

A quick compilation of the code and running of the application shows that all of the functionality is intact – as shown below.

Adding a second PivotItem for the Countdown timer

We will now introduce the Countdown timer as a second feature, by adding another PivotItem and including the TimeSpanPicker control that we have installed above. This is very simply done with the following xaml code for adding a second PivotItem in the Pivot control xaml that was shown above.

We then add a second ApplicationBar resource as shown below

Here we have a two buttons – the play button to start the timer, and a cancel button to cancel the timer before it counts down. We have defined a handlers named “countdown_play_Click” and “countdown_cancel_Click”. We will add code for it soon, but for now, we will simply add the handler as an empty function (likewise for the other handler too).

Note that the cancel button is disabled by default. Also, we have copied down the cancel icon into the images folder and have set the build action to content.

Changing the properties of the TimeSpanPicker control

It is now time to beautify the TimeSpanPicker control and set some properties so that it is consistent with the properties we had set for the Stopwatch display timer TextBlock. If you click on the PivotItem in the xaml file that represents the TimeSpanPicker control, you will get it displayed in the designer mode as shown below

To beautify the control, I would like to set the background color to black, the text color to yellow (just to add a bit of color, like we set Stopwatch display to blue), set the font to be a fixed width font (courier new), and set the font size to 64.

As in the case of the Stopwatch Display Timer, I found the most effective way to do this is to create a style in Expression Blend and apply it to the control. Here is the style that I have created and saved in App.xaml file

I simply apply the style – TimeSpanPickerStyle2 to the TimeSpanPicker control, as shown below, and you can also see the control now looks a lot nicer in the design view. I have also adjusted the location of the TimeSpanPikcer control to be around the same place as the Stopwatch Display Timer control.

The beautiful editing capability of the TimeSpanPicker control

The TimeSpanPicker control has a very nice built-in editing capability for changing the hour, minute, second portions of the display. The display is a TextBox, but when the user selects it, you can change the values using the infinite scrolling capability that it provides, keeping in mind the range of the values for hour, minute and second!

Notice below, how it looks like in real time. The picture on the left shows the display mode of the control. When you click on any of the three fields, it brings up the infinite scrolling control and you can get it scrolling by swiping it and then selecting the value you want. In this mode, the bottom of the screen shows the save and cancel buttons which can be used to save the new value. Thus, by clicking the save button, you get the new value for the control as shown in the right most image.,

However, note that to get the save and cancel images to show properly, you have to few steps explicitly (I presume this is an issue with the control – it should really have done all of these at the time of the package installation time).

You have to create a folder at the top level of the solution called "Toolkit.Content" and put the icons in there. You will need to copy the icons from the Coding4Fun.Phone.TestApplication project. They need be named "ApplicationBar.Cancel.png" and "ApplicationBar.Check.png", and the build action must be "Content"!

Finally, the logic for the Countdown timer

To keep the logic for the Countdown timer simple, here is what I will do:

Introduce a new DispatchTimer, let’s call it countdowntimer and a stopwatch called the countdownstopwatch.
When the “play” button on the Timer screen is hit, we will

Convert the value in the timer to number of ticks, saving it, and setting that as the timespan interval for the counter
Set an event handler for the timer
Start the timer and the stopwatch
Disable the play button and enable the cancel button

In the event handler of the timer

We will get the elapsed timer time from the stopwatch, subtract it from the total number of ticks saved above to get the remaining time
If the remaining time is still positive, we will set the value of the TimespanPicker control to the remaining time
If the value has reached zero, we will stop the timer (we will soon sound a beep too)
We will also enable the play button and disable the cancel button

When the cancel button is clicked, it simply resets the remaining time to zero and the event handlers take care of the rest

The code looks as follows:

Sounding a beep when the Countdown reaches zero

Playing a sound when the countdown goes down to zero turned out to be harder than I thought. I will investigate if there is an easier way, however, for now I am accomplishing this using XNA.

First, I add couple of XNA class library references

Next, I add a audio file - Piano.wav - to the root of the Application. I also changed the “Piano.wav” as Content and “Always copy to Output Directory” in the properties of the .wav file. Finally, I add the code below when the countdown reaches zero.

How does the application looks?

It is time now to build and show-off the features we have added. First notice the main screen of the application in the image shown on the left. You will notice that next to the “StopWatch” title, you will see a portion of the “Timer” feature shown in gray. This is a view of the Pivot control. It shows that there is another feature in the application! If you swipe the surface of the phone, it brings the second feature into view – as shown in the image on the right. Notice how the titles of the features are positioned – the Timer is now active, and the Stopwatch title shows partially and is grayed.

I can use the TimeSpanPicker editing capabilities discussed earlier and set a countdown value – as shown on the left below. When we save the value, you get the second image from the left – notice that the play button is enabled and the cancel is disabled. I then hit the play button and the third picture shows the countdown in progress and I also show it in a flipped view. Notice that the cancel button is now enabled, and when I click that the count goes to zero, as shown in the last picture below, and the piano sound plays as well!

That was truly a lot of fun! I have touched upon a ton of functionality, and I really enjoyed getting the application into shape and posting this!

Cheers!

Continuing with the Windows Phone applications–.NET Serialization

2011-04-23T10:13:58Z

The Chronometer application I have been building for Windows Phone 7 is coming along nicely! This has mostly been a weekend project, as I don’t find time to get to it during the working days. The Stopwatch functionality is almost complete. In the last post I introduced the concept of data binding and persistence. I can now record a series of Stopwatch events, name the events, and when I exit (or tombstone) the application, I can persist them into a file.

In this post I will incrementally refine the application in a few different areas. The first one is to make the code for saving / loading the timings to and from the file lot simpler, by leveraging the power of .NET serialization.

If you remember, I had stored the timings from the Stopwatch in an in-memory data structure defined as follows:

This is essentially an ObservableCollection object which represents the collection of timings. The object itself takes care of providing notifications when items get added, removed, or when the whole list is refreshed. The definition above takes a template for the class <Timings> which represents individual elements in the collections. The definition of the “Timings” class is shown below. Each element essentially is a tuple of two strings “EventName” for the name of the Stopwatch event, and “timingsinms” representing the time for the event.

The code to then save and load the in-memory collection object into a persisting file was explicitly written as:

Leveraging .NET Serialization

.NET provides the System.Xml.Serialization namespace that contains objects to help serialize objects into XML documents which can then be saved in files. Likewise, it provides classes for the deserialization too. You can read all of the details about .NET serialization here.

There are two options I can take - either to do an XMLSerialization or BinarySerialization. I am choosing XML since I could have a look at the file I need to and also tweak to choose the elements to be stored.

Since we are using an ObservableCollection which is part of System.Collection and types in System.Collection and System.Collection.Generic are by default Serializable. So it’s east just to serialize the entire collection with one line of code.

We first add System.Xml.Serialization as a reference, and include the name space in our project

We then create an instance of the XmlSerializer class using the type of the object we want to serialize.

With this, the saving and loading of the in memory collection to the file become a lot easier.

To serialize to the file, the code now looks like the snippet shown below. We simply create a StreamWriter object for the file we have opened or created, and then serialize the instance of the XmlSerializer object (which has already been created of the write type), by calling the Serialize method, passing in the writer and the actual in memory collection as the parameters.

Loading the collection back in to memory is equally simple.

Note that the ObservableCollection does not fire the NotifyPropertyChanged when the whole collection is deserialized. So we overcome that by setting the Itemsource of the TextBox to the Collection once again.

Handling the Application state during Deactivate and Closed events

For the Main Application you will see there are four events that need to be handled and you can see the event handlers stubs already written for you in App.Xaml.cs. In our case we want to handle the case where when the user presses the back button or when the Windows button is pressed or when the user powers off the mobile when the app is in use, we want to store what we have in in memory list.

Currently we just have one screen and we will handle the Deactivated and Closed events when the main screen is being tombstoned.

Let’s first add the event for handling the de-activation. This is also an opportune time to show off a Visual Studio short cut mechanism to define and add these event handlers. Simply type:

“PhoneApplicationService.Current.Deactivated +=”

Then hit the <tab> key twice. The code automatically expands to defining a default handler and setting the above event to the handler. See below

We will replace the default implementation with a call to “saveTimings” and likewise define and do the same for the Current.Closing event. The code for both is shown below.

Since we are loading the timings when the application loads, and saving them when the application is deactivated, we no longer need to save the timings when the “Save” button is clicked – we will simply let the data structure build up in memory.

Formatting the time

Earlier we were calculating the time down to seconds and milliseconds by dividing the elapsedmilliseconds. We will now write it to the TImeSpan class and find out the Hours, minutes, seconds and milliseconds in one line of code.

Fixing the font size and color of the timings

Finally some aesthetic changes. I had noticed that the display style of the event name and that of the timings string were not quite the same. I have fixed that by appropriately defining the foreground brush for the TextBlock and its font size too – as shown in the XAML snippet below

That completes the Stopwatch functionality.

A quick test shows that the displays are looking much better, and the functionality is all intact

Hitting the back button or hitting the “windows” button to tombstone button and getting back to the application also shows that the timings data is correctly being persisted and restored back

My goal for the next session and next post is to add another feature to the Stopwatch – that of a count down timer. That will need me to add another page to the application or perhaps a panoramic view – that will be fun!

Cheers!

Building a Windows Phone 7 Application–Data Binding and Persistence!

2011-04-16T17:38:41Z

The IPLT20 cricket championship is currently in progress – this means there is a lot of cricket on Television. Usually a couple of games from 4pm to almost midnight! If you don’t have any other plans, these games are a great option to while away your evenings. I spend some time on the weekends watching these games. But I now have a happy solution to ensure watching the games doesn’t just become recreation but otherwise an unproductive use of time – I can continue to extend my Windows Phone Application and blog while I watch the games – woohoo!

It is time to add some new functionality and new concepts to the Chronometer application I have been building. I have posted a set of three blogs so far on it, with the first one being here.

The new functionality that I will add

In this post, I want to add the support of the “Save” functionality to the Stopwatch. If you remember, in the second post I had introduced the “Save” button in the Application Bar – however, I had not added any code for it. In this post I will add the following functionality.

The “Save” button will be enabled only when the Stopwatch is in paused state (disabled with the watch is running)
When you hit “Save” it will do the following:

“Copy” the time on the Stopwatch to a new line below the Stopwatch
Any existing lines will be pushed down one row
Each new line will have a default name, and the Stopwatch time against it
The name of the line should be editable
The list of lines should be scrollable
The “Save” button should also reset the Stopwatch to “00:00:00:00”

Persistence and data binding too

It is important to mention here that, in the current release of the Windows Phone 7 only one application runs at a time. When you back out of your application, it gets suspended which is known as the “Tombstone” notion. While you get notifications of when the application gets tombstoned, but there is no guarantee that the application will be resumed from the same state when you go back to it. It may have gotten terminated (you would know that in the notification) and restarted. Hence it is important to take care of data persistence explicitly across tombstoning and restart.

I would like to save the list of timings displayed above from session to session.

For this, I will introduce the concept of persistence of the data in file, and I will also introduce the concept of data binding so that it makes it easy to associate and bind the data in the application screen to the file it is persisted in.

I am looking forward to learning a lot as I do this!

Creating the visualization of the area where timings are saved

I want the timings to be displayed as below:

<default timing name> <hh1:mm1:ss1:ttt1>

<default timing name> <hh2:mm2:ss1:ttt2>

……..

<default timing name> <hhn:mmn:ssn:tttn>

While the name on each line starts with a default name (say “timing”), I want the name to be editable – so it needs to be TextBox. The actual value of the time however will be read-only (that value when save was hit) and hence it will be a TextBlock.

First, a basic education in data binding to a control

Let us first understand how data binding to a control works. There is already an excellent MSDN article here. Please study the article, especially the following concepts that we will use in our application.

You have source and targets for binding, and a target is setup for binding using the “{Binding}” attribute value
There are two modes for binding – one way, and two way – via the BindingMode.OneWay (default) and BindingMode.TwoWay settings
The DataContext property of a framework or ui element allows it to participate in binding
The ObservableCollection<T> class that represents a dynamic data collection that provides notifications when items get added, removed, or when the entire list is refreshed
The INotifyPropertyChanged interface that notifies clients that a property value had changed
A DataTemplate that enables to customize how lists are displayed in a control, and ItemsControl.ItemTemplate that gets or sets the DataTemplate
The ItemsControl that can be used to represent a collection of items

At this point we are ready for create the new visualization that we need for our feature

The main content display XAML

I have created the design for the new content, and the XAML for that is shown below. You will notice that we have the “TimerDisplay” TextBlock at the top – this is the main display for the Stopwatch which we had introduced in the earlier posts – nothing has changed, I have however taken it out of the Grid which defines the new visualization that I will introduce now (and adjusted it’s margins to re-align it to where it was in the earlier posts.

The new <Grid /> now introduces the new display. Notice the following carefully:

For the make the entire Grid databound by marking DataContext=”{Binding}”.
The Grid essentially contains a ListBox “MainListBox”, and note the ItemSource property and it is bound to “inmemList” which will be an in memory list
The ListBox has a StackPanel which essentially stacks up a TextBox for the name of the timings, and the TextBlock to save the time
The “Text” property of the TextBox and TextBlock are set to data bound to EventName and timingsms variables.
Both of the above are set to TwoWay data binding

The data structure that will hold the list of timings in memory

As described earlier, the list of timings that the application will display is essentially a collection of tuples – with each tuple holding a string that represents the name of the event for which the Stopwatch was being used, and another string representing the timing value for that event.

We want to represent this as an ObservableCollection object with a class that holds the above tuple strings. This object will also fire the INotifyPropertyChanged event when any of the strings are changed. The data structure is simply the following:

Persisting the timings collection into a file

Now lets get to the code that saves the above data structure – the timings collection – into a file, which essentially will be our backing store

The code for this is pretty simple and almost self explanatory. Here it is:

Note, in the above code GetUserStoreForApplication essentially obtains a user-scoped isolated storage corresponding to the calling codes application identity. I will simply use a flat text file in the above storage for serializing and deserializing the timings collection data structure.

Here is the code which saves the data structure into a file, one line per timing tuple. It creates the file “acstopwatch.txt” if it is not already on the device, or opens it if it is there. The function is called with the collection. It then simply enumerates each element in the collection and writes out a line with the EventName and the timingsinms strings, separated by a comma.

The loading of the data structure from the file is likewise pretty simple. It opens the file, clears out the in-memory collection, reads one line at a time, and then splits the string at a comma to get the two texts stings that it creates a new Timing structure in the collection.

We will now do the initialization – where we will read the file, loading the in memory data structure, and set it as the data bound source for the MainListBox in our display that we created earlier in XAML. Note the last three lines in the code snipped below.

The application visibly looks no different yet

At this point we will build and run the application – and as expected, the application is visibly no different. The screen shot is shown below, and is really still where we had left off in the last blog. This is because while we aren’t really creating items in the MainListBox yet – that is the logic we now need to build into the play and save buttons. That comes up next.

Wiring in the new play/pause and save logic

First we add the save handler to the save button in the application bar. At this point I also take the opportunity to rename the handler for the play button to what I had in the previous post to the following:

The play_click logic keeps the save button disabled while the stopwatch is in play mode, and enables it when in the pause or stop mode

The save logic is pretty simple – it adds a new item to the timings collection, gives it a default name based on the number of items in the collection, and resets the Stopwatch

Now we see the new UI and the Stopwatch logic is in place

We are now ready to run the application. The screen below shows the Stopwatch running – see the save button displayed, then the pause mode where the save button is enabled, and on clicking the save notice the new line which shows up below the display.

Notice, since the event name is a text box, you can simply type in it to change the default name – as shown below

Improving the style of the TextBox

I don’t like the default look of the TextBox – the gray object – shown above. I would really like it to be like the TextBlock shown to the right. Perhaps there is a way to do this in the default designer – but this can also be done easily be designers who use Expression Blend.

My colleague at work is very handy with Blend – and he has a style which matches what I want and I would use that. For the purpose of this blog I will simply show the XAML generated by Blend for the style in question – and perhaps explore Blend at another time.

I am only showing a part of the XAML for the style, as it is a lot of XAML code (please let me know if you need the full style). I am putting this in the App.XAML file.

Next, I change the TextBox XAML definition to include the newly defined style

With that, when I run the application, the TextBox looks a lot nicer!

Some final screen shots

We are done. Here are some final screen shots. The screen shows the state after a set of timings have been added, with some event names changed. The one on right shows that scrolling works just fine!

Next we hit the back button to tombstone the application, and when we launch it again, we see that it has reloaded all of the saved timings showing that persistence is working just fine too

Finally I test to see that portrait mode works well and it does!

That completes a few hours of coding this afternoon, and the cricket match is still on! I hope this blog is useful to someone out there who wants to add data binding and persistence to their application.

Cheers!

Windows Phone 7 app: Adding “portrait”/“landscape” modes to Chronometer

2011-04-07T16:22:15Z

This one is a short update to the Windows 7 Phone application that I have been building and blogging about – you can find the starting of the series here.

The application that we have built, so far, does not respond to flipping the phone on to it’s side. For example, below are two views of the phone held upright and on its side respectively

While this behavior may be fine for some applications, for our application, the display is hard to read when the phone is turned on its side, and I would really like the display to always be “upright” irrespective of whether the phone is held upright or flipped on it side.

This is easy to do!

You can find the default settings for the “orientation” for the application in the default XAML file for the application. I am including below this part of the XAML for the PhoneApplication page

Notice the last line above. It essentially says that the “Orientation” to start with will be in “Portrait” mode, and the “Supported Orientation” is also “Portrait” only. It is this setting which is making the application behave as shown above.

You can also notice this setting in the properties window for the PhoneApplicationPage object – see this in the image on the left below – notice the values of the “Orientation” and “SupportedOrientations” properties. To support both portrait and landscape orientations, all you need to do is change the value of the “SupportedOrientations” property to “PortraitOrLandscape” – see the image on the right below.

As you change the above property, note that the XAML file automatically changed to reflect the change.

That’s all!

We can now build the application, run it, and we can now see the following results when the phone is flipped on its side.

Notice, how the button icons in the application bar also change to match the corresponding orientation.

I should also call out that, you can just as well change these properties in the code. For example, you can achieve the same result by leaving the default properties (and hence the XAML) unchanged, but add the following line in the code behind file, during application initialization.

This of course gives you full flexibility in controlling this property however you want to!

That’s all for this night! I have a few other things to add to this application, related to the “Save” button I have introduced but haven’t coded to. This will allow me to play with a few more controls and also experiment with how data/state can be persisted across sessions of the application. I hope to get to those soon.

Cheers!

WP7 Chronometer – adding the ‘Application Bar’

2011-04-02T15:22:42Z

I have been waiting to get back to the Windows Phone 7 Chronometer app that I have started to build and blogged about last week. Today’s World Cup Cricket final provides the perfect setting to sit in front of the television to watch the game and get some coding done as well!

My goal today is to add the Application Bar functionality to the application, to use a different timer construct, and also to clean up the code a bit.

Getting the ‘official’ icons

Let me start first by using some professional icons for the application instead of the self-made ones in version 1.

You will find most of the important icons used on the Windows 7 phone already on the system. These come with the Windows Phone 7 developer toolkit, and you will them in the following locations:

On 32 bit computers – C:\Program Files\Microsoft SDKs\Windows Phone\v7.0\Icons
On 64 bit computers – C:\Program Files (x86)\Microsoft SDKs\Windows Phone\v7.0\Icons

You have both “dark” and “light” versions, I will be using the “dark” versions, as I have the default dark background for my Stop Watch page. I have copied over the following icons and add them to the project for the “save”, “pause”, and “play” functionality in the application, saving them in the “Images” folder

Also, click on each of the icons, and in the properties window, change the “BuildAction” to “Content” from “Resource”

Using a DispatchTimer

In the last post I had used a Timer object. With this object, the callback happens on a different thread. Hence, to access the UI elements of the application, I had to use the Dispatcher.BeginInvoke mechanism on the object to access it. In this post, I will use the DispatchTimer object instead. For this class, the event callback happens on the UI thread itself, and I can access the UI elements directly.

To add the DispatchTimer, I add the following lines

At this point, it is opportune to point out an useful short cut in Visual Studio. To add the event handler for the DispatchTimer object all you do is simply type

timer.Tick += <tab> <tab>

Visual Studio automatically completes the rest of the last instruction shown in the snippet above, and also add the event handler code, below, automatically! I like this short cut!

Changing the display font to a fixed-width type

At this time, I will also make a few clean up changes. I clean up some of the static variables I had introduced earlier. I will also change the font type of the TimerDisplay TextBlock to “Courier New”. This is a “fixed width” font, and it will prevent the perceptible wobbling of the numbers in the timer display for the earlier version – that is, the total width of the displayed text will stay constant with this font, irrespective of the digits displayed. This requires me to change the width of the display block a bit, and I also take the opportunity to change the font color to a shade of blue to add a bit of color!

With this, the main part of the UI, and the properties of the TextBlock are the following

Introducing the Application Bar

In this version I will also introduce the “Application Bar”. It is the bar that sits at the bottom of the screen. The bar supports four icons, and have additional menu items at the bottom. The bar displays just the icons and a “…” symbol on the right (bottom left of the screen) to expand the display bar and display the additional menu items.

The Visual Studio development environment makes it easy to make to bring the application bar into play! Double click on the MainPage.xaml file and check out the bottom of the xaml code – you will see the following xaml code in a comment block

Uncomment the comment block, and you see the Application Bar show up in the XAML designer view, as shown below

I have also cleaned up some of the old timer code and removed the old button that I had in version 1. At this time, you can build the application and run it. You can now see the Application Bar on the screen. The left image below shows the default display, and you can click the “…” icon at the bottom right of the screen and you can see the application bar expand, now showing the names of the two icons used, and also the additional menu items that are included in the XAML code above.

I want to use the first of the icons in the application bar for the “start / pause” toggle for the Stop Watch, and the second one for a “save” functionality that I will introduce a bit later.

To do this, I update the XAML code in the Application Bar segment to change the icons for the first two icons to the play and save icons, comment out the extra menu items which I will not be using in this version, and also add the handler code for the two icon buttons. The XAML code for the Application Bar now looks as follows:

If you use the IntelliSense feature in Visual Studio to add the “Click” property, it will also add the handler code in the backing code file. I have changed the name to the one shown above/below

Building the solution and running it, we can now see the Application Bar displayed with the two icons we have selected.

When you click on the buttons, nothing happens yet, as I have not hooked up the code in the above handler to do the main stop watch logic. However, you will notice that the system automatically provides all of the functionality to “invert” the color of the icon when it is hit, and the subtle up-down motion showing the buttons are clicked.

Putting back the logic for updating the display

We can now put back the code we had in version 1 to update the display, taking care to put the logic in the appropriate event handlers, and accessing the new icons to update the application bar icons.

First I show below the code for clicking the first button in the Application Bar. It simply starts the DispatchTimer and Stopwatch, and simply toggles the icon images for the button from play to pause and vice-versa, and updates the icon text accordingly.

Next, I show the code in the DispatchTimer callback. It simply updates the stopwatch components, and simply updates the Application’s TextBlock display directly from the thread (without having to use Dispatcher.BeginInvoke, as explained earlier in this post).

With this, we have are now back at the functional state we had in Version 1, but with the buttons in the Application Bar. Below are snapshots of the starting, running, and paused states of the application.

Finishing up version 2 for now …

The cricket match is at a very interesting stage now – it is quite tense, the last quarter of the match remains and India seems to be in a bit of discomfort and Sri Lanka has the upper hand. I better get back to paying complete attention and supporting Team India! I will keep evolving the application with further posts …

Cheers!

Building a Windows Phone 7 Application

2011-03-26T17:37:13Z

It’s a lazy Saturday afternoon, and was the perfect time for me to do something that I have been meaning to get to for a while now. That is, to develop a Windows Phone 7 application. No, I don’t have a brilliant application idea in mind (I will get to that another day), but this was more to just get my hands wet in developing a simple application. As I was developing it, the thought occurred, that it might not be a bad idea to blog about it – it my help some other soul to learn about and get excited about building Windows 7 phone applications, or perhaps it might be useful for me to cover other topics in the future in my blogs. So here it is – a step by step tutorial of developing my first Windows Phone application!

Get Visual Studio 2010, and download Silverlight for Windows Phone

I am assuming you already have a developer edition Visual Studio 2010 (you can get more details about the product here). You also need to download the Silverlight for Windows Phone package – Silverlight being the application development platform for Windows Phone 7. You can get it here. From there you also need to download the Windows Phone 7 developer toolkit, that plugs into Visual Studio.

I am now set to create the first Windows phone application.

I will start with building a simple Stopwatch application. This type of application is already readily available in many forms in the Windows Marketplace – but as I said, the goal for this post is to just get started with a simple application. I will call this application a Chronometer – maybe I will add more functionality later.

Creating a new project, leveraging the template

Creating the shell of the application is real easy – simple create a new project in Visual Studio and choose to create a Windows Phone Application – that’s all! Check out some screen shots below.

You can just build and run the application. The application comes up in the simulator, and is pretty functional already – see the screens below! The one of the left gives you a default view of the application we are building – it has a default title for the application, and a default name for the starting page of the application. The simulator also includes fully functional buttons that you’d have on the phone. Clicking on the "windows” button shows you the start screen of the phone, complete with a tile for internet explorer (and that tile/app is fully functional too). Clicking on the navigation button next to the IE tile, you see the third screen which shows the applications already on the phone – and here you see that our chronometer application has also shown up (we should change the tile of the application here – it has simply picked up the title of the solution we have created in Visual Studio. Finally, you can click on the search button on the phone, and it brings up the Bing search application – once again, fully functional including the current day’s Bing picture and fully functional voice search capability. I love the Windows Phone 7 simulator in Visual Studio – it not only makes building your application really easy, but allows you to get a feel for it in an actual environment by giving a pretty functional feel of the Windows Phone 7 device!

Few easy modifications to begin with – change the application name and titles

Getting back to Visual Studio, you can see the XAML representation for the UI and the actual view displayed in the designer mode. You can simply click on the controls, check out their properties on the bottom-right of the screen, and change the texts. For example, I have changed the title of the application and the title of the main page below. I will build a stopwatch application for the main page.

Let us also change the name of the application that shows up in the list of applications on the phone. Click on the name of the solution in the solutions explorer, and bring up the properties page. Click on the applications tab in the properties and change both the title in the “deployment” as well as the “Tile” options property sets – see below.

Simply build and run the application again, and you can see all of the changes have been effected. Including the tilt of the application in the tile view (I simply double clicked on the application in the list on the left screen and pinned it to the start page).

It is worth reflecting on how easy Visual Studio makes developing Windows Phone applications too! With just a few very simple steps we have created the structure of the application.

Creating the Stopwatch display

Let’s now get to the core of our application. I will first add the main display for the Stopwatch page. I intend to be in the format of “DD:HH:MM:SS:mmm” displaying days, hours, minutes, and milliseconds.

Back in Visual Studio, bring down the toolbox of controls that you can choose from (via View.Toolbox menu) – see below. You have a rich set of controls to choose from.

I am choosing the “Textbox” control for the main display – it allows me to display a rich text on the page. You simply double click the control from the Toolbox to get it on to the application page. Next, simply change the properties (I have changed the display text to be 00:00:00:000 by default, and have changed the font size to 64), resize the control to the desired size, and drag and position it to the location you want.

The application display now looks as shown below. I now would like to add a start/pause button to finalize my first page for my simple Stopwatch application. For this, I simply create two icons – for play (or start) and pause – and create two JPG files for them. I used Windows Paint to create these two icons – each being a 60x60 in pixel size. I then add those two files to my solution via “Project.Add Existing Item…” menu

Next, I add a button from the Toolbox to the application screen, position it and size it appropriately. At this point this is a simple button, and the page and the backing XAML looks as follows.

However, instead of the Button being a simple Text button, I want the button to use an image – say the “play” image that I have created above. To do this, I simply add the “Image” tag to the Button definition directly in the XAML file shown above. The reworked XAML looks as follows – notice the <Image /> tag in the XML inserted in the definition of the <Button /> tag, and also that the play icon now shows up in the Button – we have transformed it into a an image based button.

With this, we have really completed our application layout! Now we need to add a bit of code for the Stopwatch logic.

Adding the code for the Stopwatch

As you can imagine, all of the action will be initiated by the clicking of the play button. To create an event handler for the button, simply double click on the button in the display view for the XAML for the main page. It creates the following code in the backing code file.

Now we will simply add the code in the event handler framework that has been created by Visual Studio.

My focus here is not to write the most efficient code, but will rather focus on simplicity.

Adding class references

We will be using few special class from the System name space – namely Media for updating the image of the button, Threading to get a timer going, and Diagnostics to use the Stopwatch object built into .NET. I start of by adding these references in the MainPage.xaml.cs file

A few member variables

I next introduce a few member variables. These will store the day/hour/minute/second/millisecond values that I will display; the state of the stopwatch (started or paused) , a Stopwatch object, and a Timer object ;

It also created two BitmapImage objects for the start and pause images that the button will display.

The start/pause click logic

Now, we move onto the code which executes when the play button is clicked. Note, this button is going to toggle between “start” and “pause” modes.

When in the stopped state (the initial state), it toggles the state, sets the image in the button to the pause button, creates a new Timer object, and also starts the stopwatch timer in code.

The Timer object is created with a callback method (updateDisplay) which we will discuss shortly. It also sets up the callback to be called with a reference to our TimerDisplay TextBlock so that we can update it. The penultimate parameter of 0 starts the timer straightway, and the last parameter of 100 sets it up to call the callback function at intervals of 100 milliseconds.

The logic is similar and simple when the stopped state is false – it changes the image of the button to play, disposes the timer, and stops the stopwatch. Note that in our application, the stopwatch can be resumed from the point of pausing by clicking play again.

The code is shown below.

The Timer callback

Finally, we are ready to plug in the last piece of code – the callback function – which will update the applications display.

The code is shown below.

We simply calculate the elapsed time from Stopwatch object, convert it into the appropriate formatted display string for the application

The application is ready!

With that, our app is ready! Simply build and run the application, to check it out on the Simulator. I show four screens below – the application listed in the list of applications, the starting screen, once the start button is clicked, and once the pause button is clicked

What’s next?

That was fun – and not bad, for a Saturday afternoon’s worth of coding. Visual Studio really does make building Windows 7 Phone applications quite easy.

So, what’s next?

There are many different ways I could extend this work – I could add more functionality to the stopwatch, or perhaps I could add another page to the application and add another functionality to the chronometer (may be a count down timer?). A demonstration of an application with two pages would be a good learning! And then of course there is the task of actually deploying the application to the app store, Perhaps I could also go into testing of phone applications. So, there are lots of ways I could take this – will wait for another lazy afternoon.

Cheers!

Test and Lab Management changes in Visual Studio Service Pack 1 release

2011-03-24T08:10:13Z

As you know, it has now been a couple of weeks since we released the Visual Studio Service Pack 1 product. You can find out all about this release, including a very detailed list of all the changes included in this release at http://support.microsoft.com/kb/983509

This was a significant release for the Test and Lab Management team too.

I had shared with you in December 2010, all of the changes we had shipped as part of the Beta build for this release. Those changes are of course there in the final release, and you can review them again here. There is only one more area that we had added support for after the beta, and I want to draw your attention to that:

IE9 support for Fast Forward & CodedUITest in Visual Studio 2010 SP1

With the release of Visual Studio 2010 SP1, Fast Forward & CodedUITest features of VS 2010 now support IE version 9.0 where customers can do functional testing of their web application in the new browser. The main aim of this release is to gain parity with IE8 support in IE9. The scenarios that worked in IE7/IE8 should continue to work on IE9 and users should be able to record in IE7/IE8 and playback in IE9 and vice versa. In this release we only support recording on IE9 compatible mode but playback is supported both in standard and compat mode. For more information on our IE9 support statement and known issues please take a look at this blog.

We have all moved to using this build for the Visual Studio 2010 product, and hope you are planning on adopting this build too! Please do leave a comment if you need additional information.

Parallelism: In the Cloud, Cluster and Client

2010-12-19T04:49:00Z

Recently I had the opportunity to keynote at the Intel Tech Days conference, and I chose to talk about the trends in Parallelism. I thought I’d share the “presentation” with you, and in the end I will certainly weave in the topic of “testing” into this. I hope you enjoy the post.

Software and digital experience is now becoming ubiquitous in our lives. Software is everywhere – it is stocking supermarket shelves, delivering electricity and water to our homes, storing our personal information in computers around the world, running nuclear plants and even controlling doomsday weapons! Moreover, with the popularity of the Internet and mobile devices, and with the advances in graphical and natural user interfaces, the creative human minds and the innovative companies are making the digital age more personal, social and indispensible.

This is leading to three fundamental trends in the world today:

Data explosion – the phenomenal growth of raw digital data
Demand for computational power for transforming raw data into meaningful information
Exponential growth in the number of users getting on to the digital super highway

The explosion of data, information and users

The data explosion itself is mindboggling. Research analysts revealed that:

Last year, despite the recession, the total amount of digital data in the world has grown by an astonishing 62 percent to 0.8 zettabytes (a billion terabytes). If you were to create DVDs with all of these data, and stack them up on the earth’s surface, the pile would reach the moon!
At this rate of growth, in 2020, the digital information will be 47 times of what it is today, that is 35 zettabytes, and the stack of DVDs would be high enough to touch Mars!

Raw data by itself is not of much use to individuals and businesses. However, if we can harness the right amount of computational power and processing speed, we can transform the data to experiences that will completely transform the lives of individuals and business users. Think about some of the experiences we can potentially enable in areas such as:

Financial modeling – personalized investment tools with rich analytics of complex financial scenarios
Personalized Immune System
Real-time Model based Computing
Individualized Semantic Search Engines

These advances and possibilities will, of course, lead to a huge explosion of individual users accessing these services over the Internet or using their computers and personalized digital devices. Here is a chart that predicts the explosion we are talking about:

Will advances in computational power be ready for this explosion?

All the above sounds promising. But transforming raw data into life-transforming experiences—that caters to a few billion people—will require a tremendous amount of computational power. Will the revolution in PC performance of the last few decades be ready for this challenge? We obviously cannot go back to expensive and huge super computers that individuals cannot have easy and personalized access to.

Fortunately, there are three great trends here, which hold the promise of solving this problem. These are:

Multi-core and Manycore client systems
The Cloud
HPC environment for the Cluster

Depending on the class of problem you are trying to solve, one of the trends can be utilized in an effective manner.

To understand the promise and the need of Manycore systems, it is important to review the advances we have made in the last several decades in the performance of the microprocessors that power the PCs and mobile devices.

For several decades now, Gordon Moore’s famous prediction in the 60s—better known as Moore’s Law now—has been driving the improvements in processor performance. The law states that the number of transistors placed on an integrated circuit would double every 18 to 24 months, which would roughly lead to similar increase in clock speed and processor performance in that time period. Companies like Intel have demonstrated this in reality, and the last several decades have seen this impact on clock speed and processor performance.

However, we are now nearing the limits of what can be physically accomplished in fabrication and layout. And as you see in the graph above, the clock speed and processor performance from Moore’s Law has hit a plateau.

Manycore systems is the answer

Further improvements in processor performance are now following a new model! Instead of relying on the increase of clock speed alone (which eventually leads to power consumption and heat emission that becomes unmanageable), chip manufacturers are now adding more CPUs or ’cores’ to the microprocessor package.

Most mainstream desktops and laptops now come with at least a dual-core microprocessor (a single processor package that contains two separate CPUs). This is a new trend. Quad and higher core processors are now entering the market. In fact, I am writing this post on a laptop which has 4-core (in addition to hyper-threading—not the topic of today’s discussion—that essentially looks like a 8-core machine!)

The ’Manycore shift’ in hardware performance will now lead to the next phase of computational power growth over the next decade. The same Moore’s Law can now apply to this type of scaling of processor performance. In fact, the following bold statement from Justin Ratner, CTO, Intel, is very relevant in this context:

“Moore’s Law scaling should easily let us hit the 80-core mark in mainstream processors within the next ten years and quite possibly even sooner”

Manycores need an equal progress in Parallel Computing

With Manycores’ processing power improvements of 10 to 100 times over the next few years, developing applications that harness the full power of Manycore systems become the next big challenge for software developers. Developers must now shift from writing serial programs to writing parallel programs!

Hardware companies have done a tremendous job in ushering the Manycore revolution. But software companies now have the responsibility of bringing in similar advances in operating systems, runtimes and developer tools. And these advances should enable developers to simply embrace the concept of parallelism and allow the platform and the tools to extract most of the parallelism that is available in a system.

The goal would be to ensure that if you have a compute intensive application, it is able to fully harness all the computational power available in the system. For example, if I have a 16-core system and a compute intensive application, the CPU usage and the spread across all the cores should ideally look like this:

The final frontier: Parallelism in the Cloud, Cluster and Client

Only harnessing the power of a single Manycore system may not be sufficient to bring the kind of experiences that we have discussed earlier to our daily lives. There are many sceanrios where we need to harness the power of many systems. Moreover, the operating system and the platform should provide the necessary abstractions to give that power and yet hide the complexities from the lives of the developers of the software. A business or enterprise providing rich information and computational intensive service to individuals, need combination of Cluster, Client and the Cloud. This enables them to optimize their investment for on-demand computing power and utilize idle computing power in desktops. This is typically the vision of teams like the High Performance Computing (HPC) group in Microsoft. An HPC solution here will look as follows:

Imagine a financial company providing the next generation financial analytics and risk management solutions to its clients. To provide those solutions it needs enormous processing capacity. The organization probably has a computational infrastructure similar to that shown above and a cluster of machines in its data center that takes care of the bulk of the computation. The organization also likely has many powerful client machines in the workplace that are unused during inactive periods. Thus, it would benefit from adding those machines during unused times as compute nodes to its information processing architecture. Finally, it will need the power of the Cloud to provide elastic compute capacity for short periods of intensive needs (or bursts) for which it is not practical to reserve computational power.

The RiskMetrics Group is a financial company that uses an Azure-based HPC architecture like the one outlined above. It provides risk management services to the world’s leading asset managers, banks and institutions to help them measure and model complex financial instruments. RiskMetrics runs its own data center, but to accommodate high increase in demand for computing power at specific periods of time, the company needed to expand its technical infrastructure. Rather than buying more servers and expanding its data center, RiskMetrics decided to leverage the Windows Azure Platform to handle the surplus loads. This is particularly necessary for a couple of hours, and the organization needs to complete its financial computations within window . This leads to bursts of computationally intensive activities as shown in the chart below:

Courtesy Microsoft PDC Conference 2009 and case study http://www.microsoft.com/casestudies/Case_Study_Detail.aspx?CaseStudyID=4000005921

By leveraging the highly scalable and potentially limitless capacity of Windows Azure, RiskMetrics is able to satisfy the peak bursts of computational needs without permanently reserving its resources. It eventually expects to provision 30,000 Windows Azure instances per day to help with the computational needs! This model enables the organization to extend from fixed scaling to elastic scaling for satisfying its on-demand and ‘burst’ computing needs.

You then get a sense of how Parallelism in Cloud, Cluster and Client is the solution for today’s and tomorrow’s innovative and information rich applications that need to be scaled to millions of users.

Finally, let us take a look at how the platform and developer tools will allow developers to easily build these massively scalable parallel applications.

How does the development platform look like?

Here’s a picture of how the development platform should look like.

‘Parallel Technologies’ stack is natively a part of Microsoft’s Visual Studio 2010 product as shown below - both for native and managed applications.

Microsoft has invested in the Parallel Computing Platform to leverage the power of Parallel Hardware/Multi-core Evolution

Developers can now:

Move from fine grain parallelism models to coarse grained application components – both in the managed world and in the native world
Express concurrency at an algorithmic level and not worry about the plumbing of thread creation, management and control
The concurrency runtime by itself is extensible. Intel has announced integration with the concurrency runtime for TBB, OpenMP and Parallel Studio

A demonstration of this capability

I will show a small demonstration of the example that supports parallelism in the Microsoft platform. I have a simple application called ‘nBody’ that is a simulation of ’n’ planetary bodies, where each body positions itself based on the gravitational pull of all the other bodies in its vicinity. This is clearly a very compute intensive application, and also one that can benefit immensely from executing ‘tasks’ in parallel.

The code for this application is just a native C++ code.

If I execute the application ’as-is’ without relying on the Visual Studio PPL libraries, the output of the application and the processor utilization looks as follows:

If you look at the Task Manager closely, you will see that only 13 percent of the CPU is being utilized. That means, with an 8-core, each core is utilized to only about 1/8th of its capacity.

The main part of the program, which draws the bodies, is encapsulated in an update loop, which looks as follows:

To take care of [n1] the multi-core presence and the platform support for parallelism, namely the PPL library, we can simply modify the update loop to use the parallel for construct shown below:

If I now rerun the program using the UpdateWorldParallel code, the results look like something like this:

You can now see that we are using 90 percent of the processing capacity in the machine, and all the cores are operating almost at their full capacity. Of course, if you are able to see the output of the program, you will notice the fluency of the movement, which is perceptibly faster than the jerky motion of the bodies with the earlier run.

What about advances in testing tools for parallelism

Testing such programs of course is going to be a challenge, and essentially the problem here is about finding ways to deal with the non-deterministic nature of the execution of parallel programs. Microsoft research has tool, integrated with Visual Studio, that helps out here. Check out CHESS: Systematic Concurrency Testing available at Codeplex. CHESS essentially runs the test code in a loop and it controls the execution, via a custom scheduler, in a way that it becomes fully deterministic. When a test fails, you can fully reproduce the sequence of the execution and this really helps narrow down and fix the bug!

In conclusion

Current global trends in information explosion and innovative experiences in the digital age require immense computational power. The only answer to this need is leveraging parallelism and the presence of multiple cores in today’s processors. This ’Multi-core shift’ is truly going well on its way. To make this paradigm shift seamless for the developers, Microsoft is providing parallel processing abstractions in its platforms and development tools. These allow developers to take advantage of parallelism—both from managed code as well as native code—and apply them for computation in local clients, clusters clouds and a mix of all the three!

Creative minds can focus on developing the next generation experiences into reality without worrying about processor performance limitations or requiring advanced education in concurrency.

Eurostar 2010 at Copenhagen – Cool show, beautiful city, freezing weather!

2010-12-11T07:09:00Z

I enjoyed my visit to Eurostar last year, and this year’s conference in Copenhagen was a very good experience too! It is always great to witness the passion around testing and quality in Europe, and the Copenhagen show was pretty cool! There were about 50 exhibitors at the Expo, and over 900 attendees. All of the familiar players were of course there – HP, IBM, and Oracle had elaborate booths! There were five vendors talking about Web performance and Load testing tools, and three vendors were focusing on developer tools, and another one presenting Model based testing. It was interesting, however, to note that more than half the exhibitors were Testing Service providers. Sogeti of course was there, and the Indian Global SI’s were well represented too – with Cognizant (one of the main sponsors of the event this year), TCS (Tata Consultancy Services), and L&T Infotech having a very prominent presence. The presence of TCS – the largest GSI in India – was surprise to some – this will serve notice to all, and the competition is sure to raise the quality of service offering!

The exhibition floor was well spread out, and Microsoft had an excellent booth location this time!

I found the Microsoft Testing tools (Visual Studio Test Professional 2010) still to be one of the most innovative - the level of collaboration that it brings about between developers, testers, and business analysts of course still being a great differentiator. I remember, last year in Stockholm, there was not much awareness around our testing tools at all – no one was expecting Microsoft to be in the testing industry. This year the awareness was much better – there were many who had heard and used the tool and were now back in our booth to hear about more details and deeper concepts. I had several team members with me – Mathew Aniyan and Darshan Desai joined my from India, Jan Willem Van Buren from the Netherlands, and Charlotte Pullich represented Microsoft Denmark. Mathew did a great job creating a pretty detailed presentation and live demos to showcase “A Day in the Life of an Agile Team”. I had a great time presenting these to end users and several customers in Copenhagen. Demonstrating the key features of Test and Lab Management live from my laptop was very gratifying – there was so much to talk about and show, and the following scenarios were quite popular and drew warm appreciation from the customers:

Ellen, the generalist tester, verifying a bug that was fixed by a developer – the efficiency, power, and simplicity of
- Up-to-date virtual test environments, with the daily build deployed and ready for testing
- A list of recommended tests that leads her to the few key areas to focus based on what had changed from the build she had
- Fast forward for manual testing – which enables us to easily verify that the bug is indeed fixed
Serge, the specialist tester, automating a test case for the regression suite.
- The ability to take one of the test runs that Ellen had already done and translate that to code with a few clicks was powerful
- (The code too is just .NET code and nothing new and complex – just the way the developer likes it)
- Adding the validations quite simply
- And, all appreciated how easy it was to play back the automated test on multiple browsers (IE and Firefox)!
Ellen performing an Exploratory testing session
- She files rich bugs – which has a lot of actionable information attached to it automatically (her devs are going to love her)
- She actually has the ability to create test cases from the interesting defects she finds, just with a few clicks
Ellen finishing up her day by authoring new tests – using shared step sets to represent commonly used test cases that she and others can reuse later.
Elvis, the developer, fixing one of Ellen’s rich bug – this is always popular, even in a conference for testers
- The IntelliTrace feature that allows Elvis to re-create a debugging session in Visual Studio directly from the bug (although of course the application is not even running any more), and the ability to observe the exceptions and events, and directly hone into the area of code which has the defect is very powerful indeed!
Not to forget about Angie, the product owner, who has full visibility into the project
- The Sharepoint dashboards showing the burdown, quality, bugs, test state, progress, and plans is very useful
- The live and up-to-date information in the portals allow her, Ellen, and others in the team to take effective action to address issues

I did not get a chance to attend Mathew’s session in the lab track – but sat in on Darshan’s talk on “Virtual Test Labs: The Next Frontier”.

Darshan was excellent in this session! When the track chair asked the audience about how much passion (the theme of this year’s conference) Darshan demonstrated, he got a resounding round of applause from the well attended conference room. I particularly liked the part where he shared some best practices around snapshots, cloning virtual environments, and managing VMs. The talk was obviously very popular, as many attendees came back to look for Darshan later, and in the following day too, to learn more from him about advanced concepts they were trying to adopt. It was great to see a team member take the role of an Industry expert!

As it usually happens, the exhibitors had several interesting activities and giveaways at their booths to draw in the audience. There was a 3-hole Golf attraction, a game of black jack, as well as interesting and popular drawings for giveaways like the iPad! Exhibitors in some big and well positioned booths were quite lonely as they had forgotten to add an element of fun in there. We didn’t have any such problems at the Microsoft booth – as Charlotte and Jan Willem – had arranged for a giveaway of the Kinect and XBOX 360 in each of the three days of the conference! How cool is this product from Microsoft? Check out the video if you haven’t seen this coolness yet! The audience at the floor were simply wowed – and we, by far, had the largest crowd on the floor before each drawing, and there was a proud winner each day!

In the last day, the crowd for the Kinect draw was unbelievably large – we couldn’t resist the temptation of talking to the truly “captive audience” one last time about the Test Professional 2010 product! It was Darshan’s idea, Mathew whipped out the demos, and I did a 90-second “keynote” about the power of Ellen filing actionable bugs leading to no more no-repro bugs! It was fun!

(Back at home, we are getting our Kinect delivered today – and I am looking forward to an invigorating afternoon with the family)!

There were more than 60 talks during the conference too – several of them very interesting! I found @dinopatti ‘s case study on Playdead – an XBOX game called Limbo, quite fascinating. Limbo has gotten several awards for it’s minimalistic design (all in shades of grey) and challenging gameplay. Dino was quite masterful in his story telling! A concept and a statement he made stuck him my mind – and it will be worth exploring.

Dino introduced the concept of “Tissue Testers”. Testers who test a game only once – so they are not biased with their experience the second time around. The primary testing for Limbo was done by about 150 “tissue” testers. Quite fascinating!
Dino also made an interesting statement about their usability testing sessions – he said, “we were interested in observing the users -not getting input from them. After all we know the direction”. A pretty bold and confident statement – I liked it!

I must also mention that it was fun to meet old friends and @misssogeti - Therese Sinter at the Sogeti booth, and once again Sogeti hosted a nice dinner for customers and partners. I enjoyed some great conversations – both business and non-business – that evening in a beautiful restaurant. It was interesting to see the famous “Artichoke Lamp” in view in the restaurant – I understand this is a famous creation by Poul Henningsen that people in Denmark are quite proud of!

This was my first visit to Copenhagen and Denmark, and my wife had reminded me not to miss an opportunity to check out the Little Mermaid. I did make a quick detour to work one day and did meet with her!

She is just about a meter tall, and I wasn’t sure why she was so famous! It was interesting to know though that she and I share the same birthday, and it was fun to read more about here after I came back.

Copenhagen is a beautiful city, but it was awfully cold (and unseasonably so) during this trip. The Microsoft Marketing and Field office was nice and the view from there (including of the sea) was quite beautiful!

There was snow everywhere, but on a sunny Wednesday, the city and sights were pristine and gorgeous.

The Tivoli amusement park was absolutely a treat to visit – beautiful, but it was bitter cold, and I could hardly stand outside!

As I got into a cab that night, after a short stretch of walk in the open, I remember I felt almost frozen with cold. “How awfully cold it is” I blurted out as I settled in. The taxi driver immediately swung the heat dial to the maximum, and opened up the vents at the back to fullest – and in thirty seconds I felt uncomfortably warm. I asked the driver to reduce the heat and he looked back at me and said – “Sir, you were complaining about the climate in my country”. I felt amused – but appreciated the pride and passion he demonstrated about his own land!

Well then – another successful Eurostar visit is over. The next one is in Manchester from Nov 21-24. I look forward to visiting again.

Here’s wishing all of you a Very Merry Christmas and Happy Holidays!

Visual Studio 2010 Service Pack 1 Beta Released–information on Test and Lab Management Changes

2010-12-10T03:27:55Z

The Visual Studio 2010 Service Pack 1 Beta is now ready for download! General availability as well as download for MSDN subscribers is now ready and you can access them via the links below. Service Pack 1 Beta of course comes with a “go live” license which means you can start using the product in production. Upgrading from the Beta to the final release of SP1, when it is available, will be supported and very easy.

Service Pack 1 Beta - General availability download
Service Pack 1 Beta – MS DN Subscribers only download

Since the launch of Visual Studio 2010 and the .NET Framework 4 earlier this year, we have also released some key functionality for our customers via the Feature Packs. We have also stayed in touch with the customers and collected feedback on issues that they have been facing. The Service Pack release is intended to address the key hurdles that you are facing, and there are some nice features and improvements included in this release.

Please refer to Brian Harry’s blog for the the high level details on all of the capability areas. In this post I will focus on the changes in the areas of the Test and Lab Management capabilities of VS 2010. In addition to fixing the high priority issues, this release also contains the fixes for customers (QFEs) that we have released earlier – so it is cumulative set of changes and I would encourage your users to upgrade to the Service Pack. In this release we have enabled unit testing for .NET 3.5, and addressed around 50 issues reported by our customers.

In the spirit of full transparency, here is the list of issues we have addressed. Please try out the release and let us know your feedback at the earliest, so that we have the chance to address any remaining top issues before we close the final release of the service pack.

Basic Unit Testing Support for the .NET Framework 3.5

Visual Studio 2010 SP1 includes the following basic support for unit tests that target the .NET Framework 3.5:

Create new unit test projects and target them to the .NET Framework 3.5.
Run unit tests that target the .NET Framework 3.5 from Visual Studio 2010 SP1 on your local machine.
Run unit tests that target the .NET Framework 3.5 using mstest.exe from the command prompt.
Run unit tests on a build agent as part of a build.

The capabilities listed above also enable developers to write unit tests, and integration tests for SharePoint 2010 applications using Visual Studio 2010 SP1.

The following are the known limitations of the support we are enabling:

The default target framework in test projects is the .NET Framework 4. If you upgrade test projects from Visual Studio 2008, they will be upgraded to target the .NET Framework 4 by default. You can edit the project properties and explicitly re-target the project to the .NET Framework 3.5.
In the .NET Framework 3.5, multi-targeting is supported for test projects that contain only unit tests. The .NET Framework 3.5 does not support any other test type, such as coded UI or load test. The re-targeting is blocked for test types other than unit tests.
Execution of .NET Framework 3.5 tests is supported only in the default host adapter. It is not supported using the ASP.NET host adapter. ASP.NET applications that have to run in ASP.NET development server context must be .NET Framework 4-compatible.
Data collection support is disabled when you execute tests that support .NET Framework 3.5 multi-targeting. You can run code coverage using the Visual Studio command line tools.
Unit tests using the .NET Framework 3.5 unit tests cannot run on a remote machine.

Issues/Bugs that got fixed in SP1

Web/Load Test

Crash in WebTest Results viewer when the test is executing
OutOfMemory exception when doing Find/Replace in Request
Devenv crashes after clicking on "threshold violations" hyperlink in test result status bar
Counters on "Page Response Time" graph disappears after run gets completed
Writing results to LoadTest DB takes long time to complete
Performance Counters are dropped during load test execution

UnitTest/TestExecution

.Net 3.5 support for unit test (See above for more details…)
Spurious TestContext output of inner tests contained inside Ordered test
Performance issue with loading test in test controller
Test run hangs when QTAgent fails to start or hangs in Main() function
Running large amount of tests on a Lab Environment leaves some tests in ‘Not Executed’ state
Code Coloring for Code Coverage is not working for unmanaged C++
TestCaseId coming out to be the SAME for all test cases that are associated with the same test method

^{TCM Server}

Warehouse rebuild takes too long
Reports: Resetting automated test results can cause 2 changes of a point to appear in warehouse as the current version

Microsoft Test Manager

Support for Expression Encoder 4.0 in Manual testing
Fixes we released as part of hotfix for Microsoft Test Manager
‘Configure Diagnostic Data Adapter-Event Log’ page is truncated in localized version of Microsoft Test Manager
Analyzing test result causes it to become most recent result in the test point trend
Remember Right-To-Left language settings across MTM sessions
Query-based test suite repopulation takes too long for large suites
Microsoft Test Runner : Crash after choosing browser type for FireFox playback
Unable to collect Intellitrace data if application under test is launched as a part of action recording for the test case
Parameterization: Can't bind parameter to password field when creating Action Recording
Microsoft Test Runner: Show test case description in MTR
API: Attachment count for test results returns 0 when iterating through large amount of test results
Performance improvements for Microsoft Test Manager

Lab Manager

VS 2010 Lab Management update
Build deploy/test workflow can't use drop locations on DFS or WebDav shares
Unable to select configuration for existing builds that have more than one configuration in a Build deploy/test workflow
Build Service Host crashes if it is running in Lab Mode and service account does not have admin privileges
When build agent and lab agent are installed on a non-lab managed VM, the build agent fail to start
Lab Management: can't change SCVMM Server configured for a TFS Application Tier

FastForward/CodedUITest

Fixes we released as part rollup hotfix
Coded UI Test Project is incompatible with Setup/Deploy projects in the same solution
UI Test Controls added to UIMap are case-insensitive
Creating Coded UI Test from existing action recording does not show up alternate credentials dialog
BrowserWindow.FindMatchingControls() throws UITestException

I am looking forward to hearing from you – my team and I are excited about supporting you and staying touch as you adopt these capabilities!

Cheers!

Eurostar 2010 in Copenhagen: November 29–December 2

2010-11-26T11:39:00Z

Eurostar – Europe’s largest conference for testers – is being hosted in Copenhagen, Denmark this year. You can find out full details about the conference here.

I am really looking forward to this conference, and hope to meet with customers and partners, and hear about their adoption of the Visual Studio 2010 Testing products! Do let me know if you are going to be attending too, or are going to be in Copenhagen next week.

You will find the following sessions from Microsoft interesting!

Darshan Desai has a session presentation - Virtual Test Labs: The Next Frontier – at 17:00 hours on Tuesday, Nov 30
Ken Johnston, from the Microsoft Office Internet Platforms team, is talking on “What We Can Learn From Big Bugs That Got Away” 08:30 hours, Dec 1
Mathew Aniyan will be taking about the Visual Studio 2010 Test Professional product at the Test Lab at 13:30 hours, Dec 1 13:30hrs

Brrr … it’s going to be cold in Copenhagen, though! Most days of the week look like:

Looking forward to learning about all of the new advances in the area of testing, and also to talk more about Visual Studio 2010 and Visual Studio Test Professional 2010!

Visual Studio 2010 Feature Pack 2 released–new set of Testing capabilities

2010-11-16T10:44:00Z

I am very happy to announce that we have just released Visual Studio 2010 Feature Pack 2 – which extends the Visual Studio 2010 product with a great set of capabilities – this time in the area of Testing. As you know, we have adopted a concept of feature pack releases which enhance and complement the capabilities we released with the Visual Studio 2010 product earlier in the year. These feature packs are available to MSDN subscribers only, and can now be downloaded from the MSDN accounts.

The first feature pack we had released was focused on code visualization and modeling feature. Feature Pack 2 is focused on enhancing the testing capabilities! The feature packs are cumulative – so, Feature Pack 2 will also include the modeling capabilities from Feature Pack 1. The Feature pack setup will ask you to install a pre-requisite QFE that contains the product changes necessary for the new capabilities.

There are three capabilities included in this release:

Testing Silverlight Applications
Recorded test playback on Firefox
A Coded UI Test editor

Testing Silverlight Applications

Testing of Silverlight 4 applications has now become much easier with Visual Studio 2010 Feature Pack 2. From Microsoft Test Manager, you can now capture action recording of your manual tests of Silverlight 4 applications and fast forward it in future iterations of the test case. When a developer is creating a Silverlight 4 application, he needs to ensure that it is test-ready. He can do this by adding a conditional reference to the Silverlight UI Automation Helper assembly. The new Silverlight 4 Test Package then establishes a connection between the Silverlight application hosted in Internet Explorer and the Visual Studio UI Test Framework. This connection is used to identify properties of Silverlight Controls. Using this infrastructure, Microsoft Test Manager can now capture intent aware action recording on Silverlight applications.

NOTE: Out of browser Silverlight applications are not supported in this release.

An automation engineer can now create Coded UI Tests which target Silverlight application. A powerful set of Silverlight UITesting APIs are now available in Visual Studio. Each Silverlight control has a rich set of properties also.

For more details see the article on MSDN - Testing Silverlight Applications with Coded UI Tests or Action Recordings

Recorded Test playback on Firefox

Cross browser testing with Mozilla Firefox is now enabled on Microsoft Test Manager and Visual Studio 2010. Any existing action recording or Coded UI Test may now be played back on the Mozilla Firefox browser. After Starting a test in Test Runner, click the drop-down list next to Play in the toolbar and select Change browser for playback.

In Coded UI Test, you can change the browser for playback using the following code snippet.

BrowserWindow.CurrentBrowser = "Firefox"

For more details, see article on MSDN - Recording Tests Using Windows Internet Explorer and Playing Back Using Mozilla Firefox

The Coded UI Test editor

In Visual Studio 2010, it is difficult to modify UI Test Files. The UI Test Files store the information about the controls interacted with during a test and the actions performed them. Updating any artifact in the UI Test file involved modifying XML or moving the code to UIMap.cs and thereby moving it out of the ambit of Coded UI Test Builder. This has been one of the top customer feedback on Visual Studio 2010. Coded UI Test Editor now makes the overall maintenance story for Coded UI Test simpler and easier. When you double-click on a UI Test file in a Test Project, it will launch the graphical editor.

You can now perform most of your maintenance activities from the Coded UI Test Editor. [renaming a method or control, updating the properties of a control or action]. If you make a mistake, use the standard Undo/Redo operations to recover. The find features will help you narrow down the method, action or control you want to act on. Whenever you select an action in the “UI Actions” pane, the corresponding controls is highlighted in the “UI Control Map” pane. Similarly whenever you choose a control in the “UI Control Map” pane, all actions which reference this controls is highlighted in the “UI Actions” pane.

For more details, See article on MSDN - Editing Coded UI Tests Using the Coded UI Test Editor

I am sure these testing capabilities will be a top draw for our customers. Do write back with your views on how you are adopting these features.

Cheers!

Archie!

2010-08-28T07:00:00Z

August has been a emotional roller coaster of a month for me.

It started on an extremely happy note. We announced the Lab Management capability of VS 2010 on August 4 at VS Live, and we released the feature on August 19. The capability is now available to all users of Visual Studio Ultimate and Visual Studio Test Professional – and you can read about the details around availability in Brian Harry’s blog.

I joined the Visual Studio Test group three and a half years ago, and assembled a team to build the Lab Management product. Putting together the team, figuring out what we would build and how we would differentiate our offering, the hard push to get part of the VS 2010 cycle, the building of the product, incorporating customer feedback and trying to ship with the rest of VS 2010 – all of this was a great experience. I held the product back to ensure that we had adequate customer adoption and addressed the important feedback we had received. A lot of hard work had gone into this product, so finally shipping this earlier in the month felt great! We had indeed built something very innovative, and getting it into the hand of customers was a fantastic feeling – it made all of the sweat and toil of the last three years well worth it! What a joy indeed!

As August winds to an end, it reminds me again, how life is such an intertwining of happiness and hurt.

Three and half years back was also a joyous time on the family front. I took on German Shepherd puppy – Archie – as the second pet in the family. He was going to be a great companion for the 6 month old Labrador (Asterix) and a darling for my boys, my wife, and me. Archie was six weeks old when we brought him in. Over the course of this time, he grew into a very handsome animal – extremely active, a great source of joy for us, and a core part of our family.

Archie had one problem though. He was extremely aggressive with all strangers – humans, animals, or birds. We have a big yard (fenced of course) in our house – and Archie would be all over the place – letting all strangers know that he did not appreciate their coming into his home. Our neighbor once remarked that Archie wouldn’t let even a fly get into our home without a good contest. I must admit I did feel proud of this trait.

We of course had to leash him up when we did want friends and others to come. I actually turned my two-car garage into a huge kennel for him – and put up steel collapsible gate that we would close and lock, he was in there.

But we had trouble. It wasn’t a completely fool-proof arrangement – we had a few occasions when our lapse led Archie to be loose when strangers were in our home and out in the open. Archie bit several people. Some of these bites were bad. I know if I were living in the USA still, the first such accident would have been his last one – I would have had to do something decisive about it. Here the system just happens to be more tolerant and lax. After each such accident I resolved to be more careful – but over time- we ran into newer lapses we learnt about – and each time, Archie would have bitten one more person. Some were complete strangers, and some were close friends. Some were complete acts of stupidity of the victims (why would the ignore the “Beware of Hunting Dog” sign on the gate and walk in?), and others were lapses on our part.

The count of such accidents rose - it reached 20 last weekend – and that was the last trip-wire for me. I finally took the decision that I would have to give Archie away :-( This led to a tremendous uproar in the family – the kids were particularly sad and angry too. Archie was too much part of our life. Ram Cherala suggested I contact Cesar Milan – though I didn’t know how I’d have possibly done that here in India.)

All of last week was very agonizing for me. How would I part with him? How could I betray his love for me? Who would I give him away to? I finally went back to the breeder that I had gotten Archie from, and he agreed that he would keep Archie in his home.

It was a sad morning today. I had to take Archie to his new home. I thought he looked sad himself – and took a last few pictures with the kids.

He has had a great time in our house – lording over the yard and sleeping on our bed.

I realized how much of a “dog’s existence” he would now have when I saw his kennel in his new home this morning

Archie reminded me again, though, how aggressive he can be with strangers – here he is clearly expressing his displeasure, and those vicious fangs reminded me of the pain he has caused to many.

Sigh! This was the right decision. I hope that Archie gets used to his new home, and perhaps I will visit him in a couple of months once he has gotten used to his new environment.

I returned back home with a heavy heart – remembering Archie’s first week in our home – an adorable and naughty pup.

Visitors to our home will now heave a sign of relief – no more to face this magnificent but ferocious beast – patrolling the boundary of our home.

But today, I know, we lost a part of our family – a faithful friend who would cheer us up when we were stressed and bothered by mundane situations. One who reminded us time and again what unconditional love was all about - yet it was I who betrayed him.

Archie – you will always be in my heart – farewell, my friend.

Watch the Lab Management announcement video!

2010-08-06T12:54:00Z

As I had written in my last post, on August 4th we announced the final release of Lab Management in the Visual Studio 2010 release. You can now watch the video of the announcement at VS Live in Seattle. Watch Voke’s Theresa Lanowitz talk about the capability – she talked about virtual lab management as the most revolutionary productization of technology since the IDE! You will see Dave Mendlen announce the final release (see a snippet of the announcement here), and finally, you will see a video demonstration by Brian Keller.

Here’s the video – enjoy!

Final Release of Visual Studio Lab Management announced!

2010-08-04T16:31:00Z

Just a short while ago at the VS Live event in Seattle, Dave Mendlen – Senior Director of Developer Marketing at Microsoft, announced the final release of Lab Management in the Visual Studio 2010 release. We are announcing the general availability of the Lab Management capability as end of August, 2010.

I am really excited to announce that, at the time of release, the Lab Management capability will be immediately available to all customers who have licenses for one of the following products:

Visual Studio 2010 Ultimate with MSDN, or
Visual Studio Test Professional 2010 with MSDN

This is a great day for the product team! We have been hard at work all this while to bring you a fantastic product – and it feels great to make this capability widely available to all of our Ultimate and Test Professional users via MSDN.

As you know, the Lab Management capability extends the existing Visual Studio Application Lifecycle Management (ALM) platform to enable an integrated Hyper-V based test lab for development teams. It brings virtualization to the core of the ALM process and automates complex build-deploy-test workflows to optimize the build process, decrease risk and accelerate your time to market. Organizations can reduce development and testing costs associated with setup, tear down and restoration of virtual environments to a known state. My own development team uses these capabilities regularly and it is very gratifying to see how it streamlines the collaboration between development and testing to help organizations achieve a higher ROI and realize the benefits of Microsoft’s entire ALM solution. Lab Management also enables testers to file rich bugs with links to environment snapshots, which enable developers to quickly debug complex environments.

The product team is already using the Lab Management capability every day!

I am including here couple of screen shots of this capability in action in the development team – and will write in more details about this in a future post.

The above is a view of the virtual lab that the product team is currently using!

Above, examples of rolling builds on the lab showing reports from a build-deploy-test run

Customers and Analysts are also very excited about the capabilities!

The Lab Management capability is receiving very positive feedback from customers who have already adopted it, as well as from analysts. Theresa Lanowitz, from Voke, was very enthusiastic about the capability and how it differentiates our product offerings in the ALM space. Here is what she and others had to say:

“Through its organic and integrated application lifecycle solution with virtual lab management, Microsoft is the first vendor to move the application lifecycle market beyond the status quo since Rational introduced RUP and Mercury introduced BTO.” - Theresa Lanowitz, Voke
“Before, creating a suitable build environment … took a full workday. With Visual Studio Lab Management we can be ready to go in 10 minutes or less”. -Jason Stangroome, Senior Developer, Readify
“The biggest bang-for-the-buck we’ve received from Visual Studio 2010 so far is definitely the lab management capabilities, in that it puts all the capabilities we need to deploy and manage a complex test environment at our fingertips. Lab Management is really slick and works like magic—it’s hard to describe; you’ve got to see it to believe it.” - Chris Menegay, Vice President of Consulting, Notion Solutions

There are some case studies too!

Here are some links to case studies published by customers who are using and benefiting from the product. These customers have all gone live with the capability even before final release!

Try it out today!

As mentioned, Visual Studio Lab Management will be available to Visual Studio 2010 Ultimate with MSDN and Visual Studio Test Professional 2010 with MSDN subscribers at the end of August. You can try it today at http://go.microsoft.com/?linkid=9739338

I am really looking forward to the wide spread adoption of this capability! Every development team which is using the Team Foundation Server (TFS 2010) as the key infrastructure for their development team, and are using Visual Studio 2010 Ultimate MSDN or Visual Studio Test Professional 2010 MSDN on the client side – will now have the opportunity to set up a local virtualized test lab, and get the benefits of tremendously increased productivity at reduced cost, just as my team and other go-live customers have experienced!

Further links and videos

Links to Videos, VHDs, and Blogs!

If you are new to this capability and would like to watch some videos first and then try it out simply, here are some important links for you.

Video: http://go.microsoft.com/fwlink/?LinkId=183021

VHD: http://go.microsoft.com/fwlink/?LinkID=195885

You can also refer to our team blog site at http://blogs.msdn.com/b/lab_management for detailed information about getting started.

I look forward to hearing about your experiences!

Cheers!

The Eyjafjallajökull effect

2010-04-18T08:50:45Z

No – I don’t quite know how to pronounce the name of this now-famous mountain, but it sure has caused a lot of grief the world over. If all was well I would have been on a flight right now, heading to the Netherlands for the Visual Studio 2010 launch event. But, airports in Europe are still closed and I have had to cancel my trip – it is very disappointing.

This morning, though, I was reflecting upon how similar the current flight disruption in Europe is to situations we face repeatedly in software development teams. A big volcano erupts in Iceland, and completely unwittingly disrupts air travel in rest of Europe. Airline companies not completely sure about which flight routes are affected, and wanting to be completely safe, grounds the entire fleet of aircrafts across continental Europe. There is lack of information and utter confusion – no body knows “when will the situation be normal again?”

Isn’t this exactly what happens in our software projects? How many times does a developer, who does not quite understand the entire complexity of a system, tries to make a targeted change in one area – only to find later, in utter horror, that things downstream have gotten broken and the entire project has come to a halt. How often are test teams in situation where they are not sure of the impact of a change and are forced to run their entire suite of test cases just to be safe – though they know this is clearly very wasteful. And how many times do you feel frustrated that you do not have enough information about the state of a project to be able to to answer the question “when will we be ready to ship?”

Visual Studio 2010 tries to address these very situations in software development, so that you reduce the unhappiness in the system and deliver higher quality software, faster. It helps you understand existing systems so that you can make changes that does not break everything, it lets you quantify the impact of changes, eliminate waste, and drive quality upstream. And it provides you great transparency and actionable insight on information that allows all stakeholders to really participate in the project.

I hope you have been able to attend one of the VS 2010 launch events in your part of the world. I look forward to continue to meet with customer and partners and lea how VS 2010 is making their world better!

Technorati Tags: Testing,Visual Studio 2010,Software Development

VS2010 Launched – great launch event in Bangalore, India

2010-04-15T17:22:00Z

April 12 was of course a big day for us. VS 2010 and .NET Framework 4 was launched with great fanfare – in 5 cities around the world (Las Vegas, Bangalore, Beijing, Kuala Lumpur, and London) on that day. In all, the launch event will be held in 30 countries around the globe, and we will be reaching out to more than 50,000 developers! This is great coverage for a fantastic product, as being part of the development team, I really feel proud of what we have built!

You can read more about the launch from Soma’s blog. Soma himself was in Bangalore for the launch. I would estimate that his keynote was attended by more than 1500 people at the Lalit Ashok. The audience really cheered for the demos, and the largest cheer was for the actionable bug demo by Stephanie Cuthbertson. Stephanie mentioned that the most common question, after she did the ALM demos, was - “How can I get the Test tools?”.

In the evening of the 12th, I chaired a panel discussion with six other panelists and an audience of about a hundred TDMs. The panelists were senior executives from companies like Infosys, Dell, NIIT, MindTree, Polaris, and ITC. The topic was about mastering the decision triangle of profitability, quality, and productivity – especially, in the context of the post reset global economy. The panelists shared a broad range of perspective and experiences – it was quite clear that one good thing about the economic meltdown was that there was much more scrutiny on software projects – a push for better business processes, increased transparency and efficiency, and much higher accountability. That’s exactly what was needed – we have tolerated software project failure and mediocre executions for too long. The panelists were unanimous is their opinion that well integrated ALM tools are the need for the hour and will help meet the expectations of these times. The audience really appreciated the demos of the 2010 product – architectural discoverability, actionable bugs, and streamlining of processes.

The next day, I and Mathew Aniyan presented two sessions on “Advanced Development Practices with TFS and Lab Management 2010”, and “Improving Developer Tester Collaboration with Visual Studio 2010”. Each of these sessions were attended by about 300 people, and the sessions went very well. I was quite surprised by the level of interest and many questions around TFS, Coded UI, Lab Management, and the capabilities for generalist testers. It was quite clear that Bangalore really loved VS 2010 and the Developer/Tester capabilities in the product.

I also had a session on TechEd Live – a conversation with Nikhil Chinapa (@nikhilchinapa) around our testing tools. Nikhil of course is a famous VJ on MTV. I was very impressed by Nikhil – down to earth, witty, and spontaneous in how he relates to technology in his own way. I enjoyed the conversation – and so did Nikhil. He mentioned he quite understood how our approach with our testing tools was unique! I will post a link to the conversation once it is put up on the TechEd site.

There is more to be done around launch – next week I will be in Netherlands and Belgium for more events. I am really looking forward to the experience of meeting more customers and partners!

VS 2010 RC is ready for general download

2010-02-12T07:20:11Z

The Visual Studio 2010 RC release is now available for general download! You can download the bits from here. You can read Jason Zander’s blog for more details about this release.

Like Beta 2, the RC release is a fully supported go-live release that you can use for live projects and production environments.

You can find out a lot of information about the Test and Lab Management products at http://blogs.msdn.com/vstsqualitytools/ and http://blogs.msdn.com/lab_management/ respectively, including information about what’s new in the RC release, as well as a set of videos that help you understand the product capabilities.

Several customers have already installed the products in their production environments, and their feedback has been great. I would strongly encourage you to take advantage of the go-live RC release and try out the Test and Lab Management products. I and my development team will be happy to hear from you about your experiences and help you out with any questions you may have.

Cheers!

Now the Lab Management part of the Dogfooding story ….

2010-02-07T10:23:49Z

In my last post I talked about how the Visual Studio Test and Lab Management teams are dogfooding those products – that is, as we enter the home stretch of the VS 2010 release, we are using the very same tools we are building, to test and sign off on the release. We are using the RC bits, and these bits will be broadly released very shortly. My team has already blogged about all of the changes that have gone into the RC version of the testing tools – you can read about those here.

In this post, I will focus on how we are dogfooding the Lab Management product, and are benefitting from it. This really highlights all of the coolness that you can expect to see, as you use the product too. Please refer to the last post, about the infrastructure and topology that essentially makes up “lab” that my team has setup using the Lab Management product.

The first diagram that I include below shows you a view of the lab in the “Lab” activity center of the Microsoft Test Manager 2010 tool.

You can see that, in this instance, the team is using 107 virtual environments for their testing (aside from another 80 physical environments). Each virtual environment is a logical collection of a set of virtual machines that make up the environment or configuration. For example, you can see that the highlighted environment is made up of four virtual machines (the view on the right side of the tool).

While this post is not about individual features in the product, let me take a moment to talk about virtual lab environments and what you do with them …

Setting up these virtual environments is really easy – we have blogged extensively about this at the team blog site. You can create a virtual environment by selecting a set of VM templates from the library. In the RC release we have added one more neat capability which allows you to compose a virtual environment from VMs that you may already have running on the host. Many of you, I am sure, are already using virtualization in your teams and likely have VMs (virtual machines) already setup. You simply need to install a few agents on those VMs and, with the RC release, can use this new compose feature to create a virtual lab environment. As part of the creation of the environment, you can also specify that you want the capabilities to automate tests and deployment of applications (for example, the applications under test) on to those environments.

Once you have created the environments, you can use the full repertoire of testing capabilities that we provide in this release on the environments. That in fact, is how we have been doing all of the testing that I talked about in the last post.

Getting back the diagram shown above – I want to highlight one specific benefit that I myself have experienced because of this dogfooding. While we have been building this product for the last couple of years, it was always a bit difficult to get a full view of all of the configurations and environments that my QA teams were managing in the physical labs. Now, with our product, I get a complete view of all of this from my own desktop, using the Microsoft Test Manager 2010 tool! This is just awesome for me as a manager. In the above view, I got to see the different types of environments that the team is using, and what makes up those environments. I can have multiple views on this.

The view below allows me to see which host groups the environments are part of …

… or I can view of which tester owns which environments

In another view, shown below, I can see when the environments were last accessed (I am using a screen shot from middle of November). This gives me a great sense of about the resource utilization in the lab.

The seamless integration of the Lab Center with the Test Center in the Test Manager tool is a very powerful interface to keep track of all aspects of what’s going on in your test labs, and I have personally enjoyed this myself.

The build-deploy-test capability of the product has also been a great hit with the team. This essentially allows you to define a workflow which can do the following:

Schedule a build for the application under test. Once the build is done,
Select a lab environment on which you want to do some testing using the latest build
Restore the environment to a known good checkpoint (guaranteeing a clean state to begin with)
Deploy the bits of the application under test onto the (multi-tier) environment
Take a post-deployment snapshot, so that testers can return to a clean starting state for testing
Automatically run a suite of tests on the above environment, and report results

A new build of the application is really at the heart of the entire development process. An ability like above takes away all of the inefficiencies and hand-off errors around the build, and will be extremely popular in development teams (for both testers and developers – who will use this mechanism to do their own types of testing on production-like environments).

The Lab Management product extends the Team Build functionality in TFS (accessed from Team Explorer) to provide the above capability. Below I show an example of a feature team using the above feature. Notice the “deployment summary” information page that is presented at the end of the workflow – it summarizes the various steps of the workflow and the results.

At this point, I must also highlight that the ability to customize the build-deploy-test workflow is an extremely powerful capability. You can automate various kinds of testing needs using this. My team has blogged about this here. The power of this was particularly evident in our own dogfooding experience. Remember, when we are dogfooding, the “application under test” is really VS 2010 and the same testing tools that we are using. So, the event of a new build being generated becomes particularly challenging for us. As part of the deployment workflow, the same agents which are orchestrating the workflow need to be upgraded to a newer version that is part of the new build! Doing this is no easy feat, for it needs reboots in the middle and a newer version of a component to complete a workflow that was initiated by the older version. And all of this is done automatically when a new build comes out! The test team has done a good job generating the scripts and commandlets to customize the workflow, and I was very happy to observe the flexibility and power of this feature in our product.

The diagram below also shows the power and flexibility in debugging where the problem is, when a workflow fails – particularly when the flow spans multiple machines, as it did in the above case. The logs generated as part of the workflow are extremely detailed, and organized in a nice fashion (highlighting the different steps, the time they took, and the warnings/errors generated) all in one place. This is a big improvement from the situation where testers have to manually look at logs in different machines individually to see what might have gone wrong. Here all of the information is in one log that you can access from your desktop, as part of the workflow summary information.

Features like noting the total elapsed time against each of the steps of the deployment workflow also helps a great deal in making the testing process efficient. For example, as shown above, it really helps the testers isolate which part of the workflow is taking the most time and see if those need to be optimized.

Before I sign off on this story, I want to return for a moment to the first diagram in this post. I am including it here again.

Notice the highlighted environment – “TeamLab-SelfhostLE-2” and the set of machines shown on the right hand side which shows what the environment is made out of. You can see that this environment includes a load balanced TFS server, a build controller, and a test controller. This in fact is one of the environments that the Lab Management feature teams are using to test the Lab Management product. This essentially is a sort of “recursive” use of the product within itself – pretty neat, isn’t it?

I hope this post and the last one has given you a good sense of the power of the testing tools that we are building, and the extent to which we have been dogfooding them to ensure that they are really ready for our customers. This dogfooding has been going on for more three months now, and the product is looking amazing solid.

The RC bits of VS 2010 will be released shortly. Setting up a Lab certainly needs more commitment of time and resources than trying out client side only features, but you can get started with a lab of just a couple of Hyper-V capable machines to see for yourself the power of the product and how it will take out the many inefficiencies that plague a typical dev/test lab. I hope this story give you the impetus to get going on the product. I would love to see a diverse set of customers go-live with the product and share with us their success stories, before I release the product.

Cheers!

Dogfooding Visual Studio Test and Lab Management Products ….

2010-02-04T09:01:00Z

Dogfooding is a rich tradition at Microsoft. It essentially stands for “eating your own dogfood”. That is, product development teams are expected to use the product that they are building in their day to day work life, to ensure that the product is really ready for paying customers. You can find more about this practice from this blog post from several years back.

In my posts you have read about my excitement about the Test and Lab Management capabilities that are part of the VS 2010 wave of products. I am very excited about the many innovations that we are building for our customers (who are the testers and developers and business analysts in product development teams), and I love talking about them.

In keeping with the practice of Dogfooding, it then was very important for me to make sure my own development team members were using these products on a daily basis, and ensure that the products lived up to the high standards of usability, reliability, and capabilities that I know my own team needs from tools, for building world class products.

This dogfooding effort has been an important focus for my team for the last several months. All of the testers in the team have moved onto using the products on a daily basis. Their motto has been to “Be the first customer of the Test and Lab Management features, and accomplish all VS 2010 QA tasks using VS 2010 features” . The result have been great!

It is time now to share this dogfooding story with you. I hope this also inspires the readers who are part of development teams themselves, to go-live with these products. As you know, Visual Studio 2010 is currently in a go-live Beta state – and you can get more details about it here. We are also real close to releasing our next public go-live build (which is going to be an RC (Release Candidate) build.

So, let me get started on the story …

The first important point to make is that the Visual Studio Test and Lab Management product development teams are a highly distributed team. We are located in four locations across the globe, as noted below. In our teams, we have about 40 team members focused on testing the products that we are building as part of VS 2010.

For our dogfooding we use a distributed lab that uses our Lab Management product, built on top of Team Foundation Server (TFS). We have a TFS server in Redmond (known as the Pioneer server), and we have a distributed lab topology built on top of it. Here is how the lab topology looks like

The above diagram needs a bit of explanation. On the left hand side of the diagram you notice the TFS machine – it shows the application tier (which is a network load balanced setup) and the data tier machines. This is an “enterprise” scale setup of TFS – and you can get more details of this configuration from Grant Holliday’s blog post. Next notice, the “SCVMM” (System Center Virtual Machine Manager) system on the top right – this gets licensed as part of the Lab Management product, and essentially manages the host machines where virtual machines will be installed, and the library of virtual machines that a development team will use. The SCVMM server for our lab is also located in Redmond. Finally you see that each of the sites in my development team (for example, Hyderabad or Raleigh) have their own sets of machine which serve as the VM hosts in their local location, and also a library machine in the local location that stores the VMs and templates that are used in the site. This topology works great for my distributed team – all of the data intensive operations of creating and cloning virtual machines are done in the site where the VMs are being used, whereas the central TFS server and the SCVMM server orchestrates and coordinates the lab across the sites.

I should also point out that the above TFS server serves as the single repository for all of the development activities in our team – that is, it stores all of the source code for our products, all of the work items, test cases, test results, and lab environment assets.

As part of the dogfooding effort, my entire test team is now using the above Lab for all of their daily testing and reporting activities. For example, here is a view of the test plans that are owned by the team.

As my team has several feature crews who work on different parts of the product (like Load Testing, or Test Case Management Client or Server), you can see the plans created and used by the individual feature teams.

In the next diagram below, you can see more details of an individual plan – in this case an example from the Test Case Management client team.

You can see above how the test plan is composed of different test suites – for functional automation runs (FAR) or Performance runs or for exploratory testing where the suites are organized as a set of different “tours” through the product. The right hand side shows the test cases which make up the selected suite and various attributes about their current state.

Next is an example of a test plan run.

You can see the run details – the build that was used for the run and the results of the run. This gives you a sense of how the feature teams are organizing their testing, and going about the various types of test runs – executing and analyzing them.

The next important activity for them to generate repots so that we get an overall idea of how the testing is coming along.

My team heavily uses the excel-based reporting mechanism in TFS. I will show you a few examples, were specific reports can be generated by just a few clicks of the mouse.

As all of the test and development assets are already in TFS, the starting point for these reports is a query that we make on TFS. For example, below I show a query for test cases that are closed (that is, completed). You can then notice the option to create a report in excel.

This mechanism comes really handy, in creating a bunch of reports. Below are some examples of reports from in Excel.

The diagram below shows what percentage of test cases have been automated versus those that are manual tests.

The next report shows the breakdown of test work items by priority.

The final sample report shows the who are the top 10 owners of work items assigned to them.

The TFS server, as you know, also provides a SharePoint portal which in our case also works for an up to date dashboard of all of the QA activities in our team. Below is how this looks like – you can see how the latest information of nightly automation runs (NAR) and failure analysis readily available. The portal has been customized for a variety of other reports which show up as you scroll down the portal.

The entire development team is also benefitting immensely from all of the features that we have built for breaking down silos between developers and testers. As an example, take a look at an “actionable bug” or “rich bug” that has been filed by a team member.

Using our testing tool – the tester probably just typed in the title of the bug she found and hit enter. All of the rich and actionable information in the bug about the system information at the time of test, the exact steps that the manual tester executed, and various kinds of rich attachments are automatically captured in the bug. This makes it extremely easy for the developer to narrow down and fix the bug. In the above picture you can see the rich set of attachment that the developer has access to right from the bug report – for example, a video of the testing session and an IntelliTrace log for historical debugging. Moreover, in this particular case since the testing was also done on virtual machines using the Lab Management product, you can see we have a link to the virtual environment that the tests were run on. The developer can click on the link and get connected to the virtual environment right from their desktop!

I will close this post here – but there is more to the story. In my next post I will focus on the Lab Management part of the dogfooding, and how we are benefiting from the features in that product.

This is great stuff! All of the testing in my group is now being done using the products we are building, and it is great fun to experience first hand, the benefits that we are building for our customers. Quite often I will get a mail from a tester or a test lead about yet another thing they are proud of in the product – for example, here’s a quote from my Test Manager:

From: Dinesh Bhat
Sent: Thursday, January 07, 2010 10:59 AM
To: Dinesh Bhat's Direct Reports
Subject: Using Microsoft Test Manager in a real testing cycle

The product simply rocks in terms of ease of use and productivity! There are a ton of cool features. IMO, the product meets the bar for teams that use agile or formal process or for teams that are savvy about traceability. Moreover, you can really let the team work in a “friction free” manner. During this exercise, I did not pester the team a single time to know the status. In turn, I was fully aware of progress the team was making sitting right in my office! This is a great toolset for distributed development too …

The entire dogfooding effort gives me great confidence in saying that these tools are ready now for your use in your your development teams! We would love for you to adopt these tools now, and give feedback about your experiences. We just have a few more months before we close the development cycle on this release.

I know many of you are using these products already. I would love to hear about your experiences too – perhaps you can add those as comments to this post.

Beautiful Stockholm!

2009-12-07T16:22:00Z

I just got back from a week's trip to Stockholm, Sweden. This was my first trip to the city, and I really enjoyed my time there. Here’s a nice photograph of Stockholm Central that I took from my hotel.

I was there attending Eurostar 2009, meeting with my colleagues in Europe, and spending a lot of time talking to customers and partners about the Visual Studio 2010 Test Products. It was very gratifying to see how much the people loved the tools. Not only did the testing professionals love the tools, I found that the developers too were greatly inspired by the tools – it is fun to watch them get excited and animated when they realize what breaking down the walls between developers and testers will mean to them :-)

What else can I share with you? Oh – here’s a link to a podcast interview of me recorded by the Microsoft Sweden team. If you follow the Swedish language, you can listen to the entire podcast – it has a review of TechEd Berlin, and an interview with Ron Jacobs on the Windows AppFabric server, followed by the conversation with me. If you, however, just want to listen to the part where I talk about the Visual Studio Test Products (in English, of course) you can seek to about 21:30 minutes into the podcast (if you have trouble seeking with the embedded player, you can double click to bring up – say Media Player – and seek there).

The testing industry and community is very vibrant in Sweden – I’d love to get back there again!