How fast should my view load? 

How long is acceptable for logging  into an application?

When you set out to build an application, it is important to get an idea of how quickly users expect certain tasks to happen in the application. Before we can do that we need an understanding of how to dissect UI performance so that we can focus our efforts on the appropriate part of the application.

When defining UI performance, it is easier if you look at the performance in three different ways.  Actual Duration, Perceived Duration, and Tolerance.

Actual Duration

Actual Duration is the time it takes between the user’s interaction (clicking a button, pressing a key) with the application and when the user can consume or interact with the result. This is the typical performance metrics we gather, for example timing how long it takes to navigate to a view or populate a list box.

Perceived Duration

A view may take 10 seconds to load, but factors may cause that be over or underestimated, so perceived duration cannot be assumed to be veridical. We get this all of the time when getting performance reports from a user. You often hear “this app runs too slow”, “when I click here it takes forever to load”. What actually happens is that action may take 10 seconds, user perceives it to be around 8 seconds, but he/she is really willing to tolerate 5 seconds. Typically perceived duration is not accurate, but if enough users identify the same actions as slow, Perceived Duration can be used to identify perceived performance hot spots. Keep in mind, these should always be verified using actual duration before actually setting out to improve the performance.

Tolerance

Tolerance applies to how long a user is willing to wait between the moment the user’s explicit action and the moment information becomes consumable or selectable for the user. Tolerance is very important as it will help you target the areas of the application that need the most attention concerning performance during design and development. Another thing to take in account with Tolerance is the type of user your application needs to support. A typical user has lower expectations then power users. If your app is targeted at advanced users, they will expect more.

When determining classifications for tolerance thresholds, the following can be used for threshold definitions:

Instantaneous (100 to 200 ms)
Immediate (500 ms to 2 sec)
Continuous (2 to 5 sec)
Captive (6 to 10 sec)

Take these thresholds and map to specific areas in the system based on what a user would expect. The list I have devised below is a common list of tasks with their expected performance tolerance. It is not a comprehensive list, but should give an idea of how the thresholds map to tasks and what their expected performance goal typically is for most applications. You can extend the list by adding domain specific tasks with matching performance goals.

Tasks	Tolerance
Application
Application Startup time	Captive
Application Login	Continuous
Module / Feature
Navigation Time from View to View	Immediate
Search	Continuous
Response Time for Common Business Scenarios	Continuous
Response Time for Complex Business Scenarios	Captive
Displaying of Dialogs	Immediate
Controls
Showing of Dropdowns	Instantaneous
Selecting of items in Dropdowns	Instantaneous
Changing between tabs	Immediate
Checking of checkboxes	Instantaneous
Opening of Expanders	Immediate
Populating of Listboxes	Immediate
Selecting of items from dialogs	Immediate

Often the list above is collaboration between the business and technical team. When working with users I try to explain to them that all tasks cannot be classified as Immediate. In some situations it is not technically possible to get an immediate response. However, by classifying tasks in the application you can set expectations with the business and get an accurate picture of what areas of application are important to the user from a performance perspective. Sometimes this process involves some investigation to find out if certain business tasks can be performed in the time the business expects. If they can’t there are a number of things that you can do to improve the perceived performance (caching, asynchronous calls, hour glass or status dialog).

Some of the things that I do to guide the user when working with them to map tolerance to application tasks are as follows:

· Remind them that improving performance to the Instantaneous level can be expensive, so we need to make sure that we identify areas that make the most sense.

· Areas that are not used a lot should not be core focus for performance improvement initially.

· The use of perceived performance can be useful to make the user feel like the application is responsive. A hourglass or status dialog is a cheap way to improve perceived performance to an acceptable level.

By taking the time up front to define UI Performance Goals you can use the findings to help focus development efforts and spend the time improving performance where it is needed most.

A friend of mine, Scott Davis has started a gaming company with a couple of other folks.  The game is Qonqr, check them out, they are on KickStarter.

Looking for some nice Metro style icons that are customizable and free to use.  Check out MetroStudio.  They supply an app that allows you to customize the icons to the color scheme you want in addition to the size you need.  They will also supply the xaml source if you need it.

Last week I was traveling.  I came home to find that the drive on my HP SmartMedia Home Server had died.

Steps were fairly simple to get the server back up and running, but I did have one problem with configuring remote access.  Here is the process that I followed:

1. Bought 2 identical 3tb drives.
2. Installed the two drives into HomeServer.
3. Uninstalled the HomeServer Console and the Windows Media Extender.
4. Ran the HP Recovery DVD… for some reason I had to copy it to my hard drive to get it to work.  It failed the first time I ran it from the DVD drive. It basically walks you through the steps for recovery and then executes the rest unattended.
5. After the OS is installed, make sure you keep going back to Windows Update until there is no more updates left to install.  When I tried to register my domain with Windows HomeServer I kept getting:
   
   An unexpeced error has occured communicating with the Windows Live Domains service. 80000190

This was resolved by repeating the Windows Update process until there was no more updates… then configuring the domain name in Settings –> Remote Access –> Domain name

Interesting tool with an API to take snapshots of your website, which converts them into DeepZoom tiles that can be displayed on multiple devices.

Looks like there is a number of new goodies to play with from Microsoft.

This is a nice example and gives you the basics of game building on Windows 7 Phone.  It is a play on Angry Birds, an addictive game by Rovio. 

I have been working on StickerValue.com to learn the new Razor View engine introduced in MVC 3.  It looks like now I can start playing with MVC4 and bring the site to mobile devices.

I was taking a look at the 4.5 .NET Framework docs and it was really happy to see a generic WeakEventManager.  I was hoping for a more ergonomic API… but it looks like we are going to be stuck with the AddHandler / RemoveHandler syntax.  I was hoping they would get a little more fancy and supply a short-cut syntax much like what we use for subscribing and unsubscribing from .NET events.

This post is related to helping someone on the MSDN forum to try to find a memory leak in their application.  Others may find the technique useful for detecting memory leaks.

Here is the forum thread:

http://social.msdn.microsoft.com/Forums/en-US/wpf/thread/268462f3-ec45-4507-996e-70fb1f00d68f

This is a handy little LINQ extension I use all of the time to recurse through IEnumerable<T> object graphs. 

          
            /// <summary>
            ///
Traverses the specified source.
            /// 
            ///var
total =
            /// Application.Current.Resources.MergedDictionaries.Recurse<ResourceDictionary>(
            ///
obj => obj.MergedDictionaries);
            /// </summary>
            ///
<typeparam name="T"></typeparam>
            /// <param
name="source">Root object.</param>
            /// <param
name="fnRecurse">The function used in recursion</param>
            ///
<returns></returns>
            public
            static IEnumerable<T>
Recurse<T>(this IEnumerable<T> source, Func<T,
IEnumerable<T>> fnRecurse) { foreach (T item in source)
{ yieldreturn item; IEnumerable<T>
seqRecurse = fnRecurse(item); if (seqRecurse != null)
{ foreach (T itemRecurse in Recurse(seqRecurse,
fnRecurse)) { yieldreturn itemRecurse;
} } } }
        

Jason Bock just posted the sessions for TCCC8.  Looks like some interesting material… looks like there is going to be content on developing for Win Mo 7.