User Experience Design

Evolution of Windows Explorer

Andries van der Meulen — Tue, 30 Aug 2011 13:05:15 GMT

Nice post of Steven Sinofsky on MSDN blogs about the history and future of Windows Explorer.
http://blogs.msdn.com/b/b8/archive/2011/08/29/improvements-in-windows-explorer.aspx

(edit 31-08-2011)
And Martin Tirion of Microsoft Netherlands wrote about it a day later (in Dutch).
http://blogs.microsoft.nl/blogs/ux/archive/2011/08/30/windows-explorer-in-windows-8-en-user-experience.aspx

Datadrop Website Load Tool

Andries van der Meulen — Tue, 23 Aug 2011 15:41:25 GMT

In the last months I’ve experienced a lot of problems with my current internet connection. Due to mysterious reasons there have been data-drops at random times for random periods.

I’ve contacted my ISP (Online.nl), and told them my story. But every time they’ve called me back, they said that they could not find the problem. My connection was always fine.

Irritated by the fact that they could not solve my problem, I asked them what they would need to fix the problem. They answered that they need proof of the failing connection.

So I’ve created a solution.

At the moment they probably are only testing with pings, and my problem isn’t actually a failing connection, but data-loss due package-drops.
So I’ve searched for an small application that I can run on my HomeServer, which measures the internet connection.
Unfortunately I have only found Ping-testers, which wasn’t exactly where I was looking for.

Therefore I’ve decided to build my own tester.

Website Load Tool

The website load tool is a small application build on WPF .Net 4 that will download data with a configurable interval from defined URI’s.
So you set up a series of websites with an test interval of 60 seconds, and keep it running for several days.
Changes of state are written in a Log, so you can collect you own evidence of the stability of your connection.

I’ve released the application on CodePlex, so everybody is free to use it.
It also can come in handy if you need to check network-stability or the availability of your website.

Get it at websiteloadtool.codeplex.com.

Storing and retrieving WPF RibbonWindow settings (including the usercustomizable QuickAccessToolbar)

Andries van der Meulen — Tue, 17 May 2011 16:42:31 GMT

When you’re creating a desktop application you'd probably want to store some user settings.
Especially when using the Ribbon inside your application, there are several things (like RibbonIsMinimized and ShowQuickAccessToolBarOnTop) that users can set and want to keep even if the application en closed and restarted.

There are several ways to store these user settings, and you can find some methods if you search the internet. But the biggest challenge is to store and retrieve the Quick Access Toolbar content which the user can change.

Defining

First the storage of the settings. I use the application user properties which are set through the project settings.
We define the following settings:

FirstRun (bool)
WindowSize (System.Windows.Size)
WindowLocation (System.Windows.Point)
WindowState (System.Windows.WindowState)
RibbonIsMinimized (bool)
ShowQuickAccessToolbarOnTop (bool)
RibbonQuickAccessToolbar (string)

If you can’t find the right type inside the type combobox, just select [Browse…] to select it from available DLL’s. Point and Size are found in WindowsBase, and WindowState is in PresentationFramework.

Storing

Next step is storing the settings. I leave the QuickAccessToolbar out for this moment. I’ll add it later.

The storing is taking place in de code behind of the Shell, which is the main window of the current application. It is not mandatory to do this in the code behind, but for the moment it is the easiest.

I store the settings when the window is closing.

protected override void OnClosing(CancelEventArgs e)
{
    Properties.Settings.Default.FirstRun = false;
    Properties.Settings.Default.WindowSize = new Size(Width, Height);
    Properties.Settings.Default.WindowLocation = new Point(Left, Top);
    Properties.Settings.Default.WindowState = WindowState;
    Properties.Settings.Default.RibbonIsMinimized = RibbonMenu.IsMinimized;
    Properties.Settings.Default.ShowQuickAccessToolBarOnTop = RibbonMenu.ShowQuickAccessToolBarOnTop;
    Properties.Settings.Default.RibbonQuickAccessToolBar = XamlWriter.Save(buttons);

    Properties.Settings.Default.Save();

    base.OnClosing(e);
}

The RibbonMenu is referencing to the <Ribbon x:Name="RibbonMenu" > inside the Shell.XAML.
Width, Height, Left, Top and WindowState are properties of the WPF (Ribbon)Window.

Retrieving

And when the application is starting again, you just have to get these settings and set them back. The best moment to do this is in the OnInitialized of the Shell.

protected override void OnInitialized(EventArgs e)
{
    base.OnInitialized(e);

    if (!Properties.Settings.Default.FirstRun)
    {
        Width = Properties.Settings.Default.WindowSize.Width;
        Height = Properties.Settings.Default.WindowSize.Height;
        Left = Properties.Settings.Default.WindowLocation.X;
        Top = Properties.Settings.Default.WindowLocation.Y;
        WindowState = Properties.Settings.Default.WindowState;
        RibbonMenu.IsMinimized = Properties.Settings.Default.RibbonIsMinimized;
        RibbonMenu.ShowQuickAccessToolBarOnTop = Properties.Settings.Default.ShowQuickAccessToolBarOnTop;
    }
}

So far the easy part.

QuickAccessToolbar

Storing and retrieving the QuickAccessToolbar is a bit more complicated. Because this can’t just be serialized.
First I tried and used XamlWriter and XamlReader to try serialize the items inside the QuickAccessToolbar. Although storing it worked fine (it made a huge xml file), when trying to load the Xaml, I soon experienced the problem that the XamlWriter also serialized the bindings (with it’s content) i set on the command property. Unfortunately these bindings are DelegateCommands from Prism, which can’t be constructed through deserialization.

The solution is a bit complex, but it works just fine. I created my own entities for storing and retrieving the items inside the QuickAccessToolbar.

[Serializable]
public class QuickAccessToolbarButtonCollection : List<QuickAccessToolbarButton> { }

[Serializable]
public class QuickAccessToolbarButton
{
    public ImageSource LargeImageSource { get; set; }
    public ImageSource SmallImageSource { get; set; }
    public string Label { get; set; }
    public object QuickAccessToolBarId { get; set; }
    public object ToolTip { get; set; }
    public string ToolTipDescription { get; set; }
    public string KeyTip { get; set; }
    public Binding CommandBinding { get; set; }
}

Off course you can add more properties if you’re setting more attributes on the RibbonButton. These properties were everything I’ve used.

Next step is creating and storing the QuickAccessToolbar items.

#region Create the QuickAccessToolbarButtonCollection
QuickAccessToolbarButtonCollection buttons = new QuickAccessToolbarButtonCollection();

foreach (RibbonButton rButton in RibbonMenu.QuickAccessToolBar.Items)
{
    if (rButton.KeyTip != "S") // Don't include the savebutton!
    {
        QuickAccessToolbarButton qaButton = new QuickAccessToolbarButton()
        {
            Label = rButton.Label,
            KeyTip = rButton.KeyTip,
            LargeImageSource = rButton.LargeImageSource,
            SmallImageSource = rButton.SmallImageSource,
            ToolTip = rButton.ToolTip,
            ToolTipDescription = rButton.ToolTipDescription,
            QuickAccessToolBarId = rButton.QuickAccessToolBarId,
            CommandBinding = BindingOperations.GetBinding(rButton, RibbonButton.CommandProperty)
        };
        buttons.Add(qaButton);
    }
}
#endregion

And when the collection filled, I use the XamlWriter to set this data inside a user setting

Properties.Settings.Default.RibbonQuickAccessToolBar = XamlWriter.Save(buttons);

The reason I’m not using a conventional XMLSerializer is because the XamlWriter can serialize bindings.

Last step is to read the stored setting. For this I use the XamlReader to deserialize back to our custom entity.

#region Load the QuickAccessToolbarButtonCollection
if (!string.IsNullOrEmpty(Properties.Settings.Default.RibbonQuickAccessToolBar))
{
    QuickAccessToolbarButtonCollection buttons = null;
    using (StringReader stringReader = new StringReader(Properties.Settings.Default.RibbonQuickAccessToolBar))
    {
        XmlReader xmlReader = XmlReader.Create(stringReader);
        buttons = (QuickAccessToolbarButtonCollection)XamlReader.Load(xmlReader);
        xmlReader.Close();
    }

    if (buttons != null)
    {
        for (int i = RibbonMenu.QuickAccessToolBar.Items.Count - 1; i >= 0; i--)
        {
            RibbonButton button = (RibbonButton)RibbonMenu.QuickAccessToolBar.Items.GetItemAt(i);
            if (button.KeyTip != "S") // Don't delete the savebutton!
                RibbonMenu.QuickAccessToolBar.Items.RemoveAt(i);
        }

        foreach (QuickAccessToolbarButton qaButton in buttons)
        {
            RibbonButton rButton = new RibbonButton()
            {
                Label = qaButton.Label,
                KeyTip = qaButton.KeyTip,
                LargeImageSource = qaButton.LargeImageSource,
                SmallImageSource = qaButton.SmallImageSource,
                ToolTip = qaButton.ToolTip,
                ToolTipDescription = qaButton.ToolTipDescription,
                QuickAccessToolBarId = qaButton.QuickAccessToolBarId
            };
            if (qaButton.CommandBinding != null)
                SetBinding(RibbonButton.CommandProperty, qaButton.CommandBinding);

            RibbonMenu.QuickAccessToolBar.Items.Add(rButton);
        }
    }
}
#endregion

Check explicitly if the commandbinding are null, else you get exceptions when initializing the Shell.

Overview

Below the complete two methods.

protected override void OnInitialized(EventArgs e)
{
    base.OnInitialized(e);

    if (!Properties.Settings.Default.FirstRun)
    {
        Width = Properties.Settings.Default.WindowSize.Width;
        Height = Properties.Settings.Default.WindowSize.Height;
        Left = Properties.Settings.Default.WindowLocation.X;
        Top = Properties.Settings.Default.WindowLocation.Y;
        WindowState = Properties.Settings.Default.WindowState;
        RibbonMenu.IsMinimized = Properties.Settings.Default.RibbonIsMinimized;
        RibbonMenu.ShowQuickAccessToolBarOnTop = Properties.Settings.Default.ShowQuickAccessToolBarOnTop;

        #region Load the QuickAccessToolbarButtonCollection
        if (!string.IsNullOrEmpty(Properties.Settings.Default.RibbonQuickAccessToolBar))
        {
            QuickAccessToolbarButtonCollection buttons = null;
            using (StringReader stringReader = new StringReader(Properties.Settings.Default.RibbonQuickAccessToolBar))
            {
                XmlReader xmlReader = XmlReader.Create(stringReader);
                buttons = (QuickAccessToolbarButtonCollection)XamlReader.Load(xmlReader);
                xmlReader.Close();
            }

            if (buttons != null)
            {
                for (int i = RibbonMenu.QuickAccessToolBar.Items.Count - 1; i >= 0; i--)
                {
                    RibbonButton button = (RibbonButton)RibbonMenu.QuickAccessToolBar.Items.GetItemAt(i);
                    if (button.KeyTip != "S") // Don't delete the savebutton!
                        RibbonMenu.QuickAccessToolBar.Items.RemoveAt(i);
                }

                foreach (QuickAccessToolbarButton qaButton in buttons)
                {
                    RibbonButton rButton = new RibbonButton()
                    {
                        Label = qaButton.Label,
                        KeyTip = qaButton.KeyTip,
                        LargeImageSource = qaButton.LargeImageSource,
                        SmallImageSource = qaButton.SmallImageSource,
                        ToolTip = qaButton.ToolTip,
                        ToolTipDescription = qaButton.ToolTipDescription,
                        QuickAccessToolBarId = qaButton.QuickAccessToolBarId
                    };
                    if (qaButton.CommandBinding != null)
                        SetBinding(RibbonButton.CommandProperty, qaButton.CommandBinding);

                    RibbonMenu.QuickAccessToolBar.Items.Add(rButton);
                }
            }
        }
        #endregion
    }
}

protected override void OnClosing(CancelEventArgs e)
{
    #region Create the QuickAccessToolbarButtonCollection
    QuickAccessToolbarButtonCollection buttons = new QuickAccessToolbarButtonCollection();

    foreach (RibbonButton rButton in RibbonMenu.QuickAccessToolBar.Items)
    {
        if (rButton.KeyTip != "S") // Don't include the savebutton!
        {
            QuickAccessToolbarButton qaButton = new QuickAccessToolbarButton()
            {
                Label = rButton.Label,
                KeyTip = rButton.KeyTip,
                LargeImageSource = rButton.LargeImageSource,
                SmallImageSource = rButton.SmallImageSource,
                ToolTip = rButton.ToolTip,
                ToolTipDescription = rButton.ToolTipDescription,
                QuickAccessToolBarId = rButton.QuickAccessToolBarId,
                CommandBinding = BindingOperations.GetBinding(rButton, RibbonButton.CommandProperty)
            };
            buttons.Add(qaButton);
        }
    }
    #endregion

    Properties.Settings.Default.FirstRun = false;
    Properties.Settings.Default.WindowSize = new Size(Width, Height);
    Properties.Settings.Default.WindowLocation = new Point(Left, Top);
    Properties.Settings.Default.WindowState = WindowState;
    Properties.Settings.Default.RibbonIsMinimized = RibbonMenu.IsMinimized;
    Properties.Settings.Default.ShowQuickAccessToolBarOnTop = RibbonMenu.ShowQuickAccessToolBarOnTop;
    Properties.Settings.Default.RibbonQuickAccessToolBar = XamlWriter.Save(buttons);

    Properties.Settings.Default.Save();

    base.OnClosing(e);
}

Enjoy!

An accurate portrayal of User Experience Designers.

Andries van der Meulen — Fri, 28 Jan 2011 10:22:00 GMT

From this blogpost from Whitney Hess, I came to this video.
A must-see for all User Experience Designers!

ILUVUXDESIGN from lyle on Vimeo.

Microsoft Silverlight 5.0 features for developers

Andries van der Meulen — Tue, 21 Dec 2010 14:56:03 GMT

Recently on Silverlight 5.0 Firestarter event ScottGu has announced road map for Silverlight 5.0. There will be lots of features that will be there in Silverlight 5.0 but here are few glimpses of Silverlight 5.0 Features.

Improved Data binding support and Better support for MVVM:

One of the greatest strength of Silverlight is its data binding. Microsoft is going to enhanced data binding by providing more ability to debug it. Developer will able to debug the binding expression and other stuff in Silverlight 5.0. Its also going to provide Ancestor Relative source binding which will allow property to bind with container control. MVVM pattern support will also be enhanced.

Performance and Speed Enhancement:

Now Silverlight 5.0 will have support for 64bit browser support. So now you can use that Silverlight application on 64 bit platform also. There is no need to take extra care for it.It will also have faster startup time and greater support for hardware acceleration. It will also provide end to end support for hard acceleration features of IE 9.

More support for Out Of Browser Application:

With Silverlight 4.0 Microsoft has announced new features called out of browser application and it has amazed lots of developer because now possibilities are unlimited with it. Now in Silverlight 5.0 Out Of Browser application will have ability to Create Manage child windows just like windows forms or WPF Application. So you can fill power of desktop application with your out of browser application.

Testing Support with Visual Studio 2010:

Microsoft is going to add automated UI Testing support with Visual Studio 2010 with Silverlight 5.0. So now we can test UI of Silverlight much faster.

Better Support for RIA Services:

RIA Services allows us to create N-tier application with Silverlight via creating proxy classes on client and server both side. Now it will more features like complex type support, Custom type support for MVVM(Model View View Model) pattern.

WCF Enhancements:

There are lots of enhancement with WCF but key enhancement will WSTrust support.

Text and Printing Support:

Silverlight 5.0 will support vector base graphics. It will also support multicolumn text flow and linked text containers. It will full open type support,Postscript vector enhancement.

Improved Power Enhancement:

This will prevent screensaver from activating while you are watching videos on Silverlight. Silverlight 5.0 is going add that smartness so it can determine while you are going to watch video and while you are not going watch videos.

Better support for graphics:

Silverlight 5.0 will provide in-depth support for 3D API. Now 3D rendering support is more enhancement in Silverlight and 3D graphics can be rendered easily.

You can find more details on following links and also don’t forgot to view Silverlight Firestarter keynote video of ScottGu.

http://www.silverlight.net/news/events/firestarter-labs/

http://blogs.msdn.com/b/katriend/archive/2010/12/06/silverlight-5-features-firestarter-keynote-and-sessions-resources.aspx

http://weblogs.asp.net/scottgu/archive/2010/12/02/announcing-silverlight-5.aspx

http://www.silverlight.net/news/events/firestarter/

http://www.microsoft.com/silverlight/future/

From http://jalpesh.blogspot.com/2010/12/microsoft-silverlight-50-features-for.html

Silverlight essential downloads

Andries van der Meulen — Tue, 16 Nov 2010 10:57:08 GMT

For those working on Silverlight project (including myself) this list comes in very handy when setting up your development environment.

http://www.timmykokke.com/silverlight-downloads/

Thanks Timmy.

Gesture-Based Computing Uses $1 Lycra Gloves

Andries van der Meulen — Thu, 03 Jun 2010 08:25:37 GMT

Interacting with your computer by waving your hands may require just a pair of multicolored gloves and a webcam, say two researchers at MIT who have made a breakthrough in gesture-based computing that's inexpensive and easy to use.

Very, very cool!

Silverlight Resize Drag Behavior for targeted UIElements

Andries van der Meulen — Tue, 20 Apr 2010 23:19:02 GMT

I have been searching for a Silverlight behavior where you have the ability to resize a column. Normally you can do such a thing with a GridSplitter onto a grid with several columns.

Unfortunately this doesn’t work when you also wants to implement something like a hide and show menu column.

Therefore I created this behavior myself and released it on CodePlex. So if you are developing a Silverlight application and you find yourself in need of a simple behavior that allows you to resize an element by dragging either in height or width, go to the ResizeDragBehavior on Codeplex.

The solution also includes a sample project where you can see how you can easily setup a menupanel-based interface.

The behavior is fully compatible with Expression Blend.

The Ten Commandments of User Experience

Andries van der Meulen — Tue, 30 Mar 2010 12:23:10 GMT

1st commandment

The user is always right

You are not the user. Neither is your boss
2nd commandment

Understand the User
3th commandment

Avoid Solutioneering

Identify & fully understand problems before finding solutions
4th commandment

Form follows function

Form must play within the general realm of the familiar for easily understood functions.
5th commandment

Content is king

Design is about communication, and takes more than pixels to communicate.

95% of web users do not read 80% of your content.
This doesn’t mean that your content isn’t important, it means it’s more important.
6th commandment

Innovate, do not Imitate
7th commandment

Access is for Everyone
8th commandment

Plan before you Design

With our users in mind and the right vision, we can plan, and develop successful applications.
9th commandment

Understand the Goal

Executives can no longer afford to formulate strategy without embracing user experience.

If your website could do only one small thing, what would that one thing be?
10th commandment

Learn from Failure

Failure is success if we learn from it.

From Nick Finck and Raina Van Cleave’s presentation from SXSWi.

Home Server µTorrent IIS Web Access Client

Andries van der Meulen — Thu, 11 Feb 2010 09:22:00 GMT

At home I have a Windows Home Server which also has µTorrent running as a service. Luckily this application comes default with a Web Access which allows you to manage µTorrent without having a user logged in on your server. (installing µTorrent on your server as a service described here.)

What happens is that the Web Access is made available on another port. Something like http://homeserver:39295/gui/. And this might become a problem if you want to reach your Web Client from outside your personal network. Of course you can solve this by setting the port-forwarding, but in my case I wasn’t allowed to reach non-default ports when I was at work. The firewalls block these ports.

But because I am allowed to reach the default port 80 on my home server, I wondered if it was possible to have the Web Client on the IIS of the Home Server. Unfortunately is the µTorrent Web Access client not meant for this, so I looked around to see if there where other Web Access clients which does the same.

I did found one solution, and although it worked, it wasn’t exactly what I had in mind.

So i created a little personal project to create a really simple µTorrent Web Access client that runs on IIS, so I have access to it from work. And now I have something working, I might as well share it for those who want to use it (or extend it).

It is a very basic solution, with lots of improvement possible. But it works.

The communication with µTorrent is realized by the DLL in the µTorrent Web Client API Wrapper Library project on CodePlex. This worked like a charm, except it throws an exception when trying to delete a torrent. (Can’t figure out what it is, but the functionality still works, you just receive a message)

My solution is based on the ASP.NET Ajax Control Toolkit, so if you wish to develop on it, you need that installed.

Download here the entire solution:

uTorrentIISClient.zip

Download here the Web Access client:

uTorrentIISClient.zip

Article published in SDN Magazine

Andries van der Meulen — Mon, 21 Dec 2009 09:25:00 GMT

SDN Magazine published my article about User Experience Design in their last edition. This article (in Dutch) can also be read here on their website.

In Control

Andries van der Meulen — Tue, 10 Nov 2009 07:55:49 GMT

What I realize more and more is that the end-users wants to be In Control. This applies especially with new developed applications that automates some of their work. By default users are skeptic. The application have to earn their trust. The more they get the feeling they are not in control, the less trust and the less acceptance of your newly developed product.

Only when the product doesn’t automate or replace existing work, an employee is likely to accept the application more easily. But still you first have to prove it and earn the users trust.

So what can you conclude from this:

At the moment you are working on a project that will automate a part of the users work, try to learn how he does that work, and don’t take away his flexibility. It´s allright that the application makes decisions and perform actions that he normally did, but certainly in the first releases, let him be the one that controls the final action.

For example when it comes to communication with customers. Originally he had to write and send the emails by hand. A desired functionality of the application is to do this automatically. A good approach to fully reach this functionality is to split it in several releases.

In the first release make sure the user can see all the emails that are about to be send, let him edit the emails if he likes to, and let him push the button that finally sends the mail. The user can see what the application is doing, and will build some trust with it.

So in the second release you extend this functionality with a scheduler and a “do send” / “do not send” checker. The user have to “check” the emails for “do send” and they are send automatically on a configurable time. The user can see if the scheduler works and that the emails are send correctly. So the trust in the application increases more.

In a third release all the emails are set default to “do send”, and the scheduler sends them every half our (or something). The user doesn’t really have to look to the emails anymore, because he now trusts the functionality of the application. He still has the possibility to go and check the emails, alter them, deny them or disable / configure the scheduler.

If you do it this way, the user feels he is In Control. So the acceptance of the new product is much higher then if you fully automate the sending of email, but nobody had the ability to check or prevent what is being send.
Even if a system is flawless and everything is working exactly as designed, there will always be exceptions in the process. And if the users don’t feel they can do anything about it, they get the feeling they are not in control. It is very likely that your new application won’t be accepted.

Just make your users feel they are In Control!

A plea to my developer brethren about designer/designers

Andries van der Meulen — Tue, 20 Oct 2009 10:40:19 GMT

This post of Tim Heuer is something I completely agree with! So if you’re a developer and you work with designers, you do need to read this…

Since we appear to be in another revolution on user interface (UI) design and user experience (UX), I’ve seen a lot of people, companies, sites refer to the designer-developer workflow, including Microsoft. Heck we’re building tools around it for Silverlight and WPF development! One thing I see too often though is the conversation being diminished to UI only.

I’ve heard conversations between developers saying things like yeah, now we just need a designer to make things look pretty or we take what the designer made pretty and put functionality behind it.

I have a plea for my developer brethren: please stop using the word pretty and diminishing the role a designer plays in defining UI/UX.

To me when I hear this I cringe for two reasons. First, while I’m not a designer, I consider myself to have a strong appreciation for design and know that it isn’t easy to execute on a design for everyone. Second I know many talented people in the design world who understand much more about how UI affects end user productivity and emotion more than just ‘making it pretty.’ So please stop, it’s insulting to the trade I think.

Imagine if you heard a conversation of designers…

Designer A: Sweet design man, I love how you anticipate the user’s next interaction and use the typography to really identify that action.
Designer B: Yeah, it took a lot of research and usability observations, but I think we got it right. I hope the developers can finish this up so we can get it in the user’s hands.
Designer A: Totally, I’m sure they’ll finish the macros soon, I think it’s all wizard based anyway.
Designer B: Yep, I mean, I’ve created an Access application before, how hard can it be.

Yeah, see what I mean? If you are insulted by hearing someone talking about the development craft reduced to macros and Access, then you should realize you’re doing the same thing. Design is a craft just like software development and there are patterns and meaning to things that designers do, both in interactive design and print design. It isn’t just about picking the right template. Sure, palettes and animations are a part of the design, but their intent in the final design usually isn’t without thought. Reducing a designer’s craft down to a simple “pretty” isn’t cool…at all. And I’ve been guilty of it.

If you want to work with a designer, then do it, but don’t hand them your finished product and ask them to make it pretty. Make them a part of the process and have them help identify the right UI/UX for the application. I realize it isn’t easy and sometimes isn’t possible to always have a designer, but when you have that need, just make sure you respect the trade or don’t be surprised if you get this book in the mail. Take a moment and learn what makes good design. For a start, watch Robby’s session from MIX08: Design Fundamentals for Developers.

I’ve got it off my chest…and I leave you with this:

Cheers.

Tim Heuer

OS Desktop Experience

Andries van der Meulen — Thu, 08 Oct 2009 05:58:54 GMT

The other day I was talking about how exactly the transition will be when switching from mouse/keyboard to touch when it comes to the User Experience. For example your operating system desktop. And then I came across this promotional video of BumpTop.com. Really nice!

Desktops are very personal, so I really don’t expect that the majority will use this. But it really is a nice approach that I simply just couldn’t ignore.

p.s. Sorry for not being able to embed the video in the page. Something with the blog-engine.

Augmented reality

Andries van der Meulen — Fri, 25 Sep 2009 13:48:00 GMT

It’s not like I'm a trend-watcher or something, but what I really noticed is the increase on topics for augmented reality.

Augmented reality basically adds a layer onto the reality. This can be done using a hand-held device.

Here are 2 cool video’s I saw last week that shows what can be done.

ARhrrr - An augmented reality shooter

Augmented Reality Pool (Skip to 02:01)

This will bring a whole new experience to end-users. Not just for information when you’re walking down the street. But just think about the possibilities also for Line Of Business applications.

In Logistics. Where information about vehicles, packages, assembly lines, etc. are shown when the planner, mechanic, driver, etc. are walking by.

In a lab. Where you can see all the information on various ingredients and mixtures.

In a storage department. In a grocery store. Almost everywhere where people work with real-life products, augmented reality can have real benefits.

I can’t wait to see this technique evolve and be able to use it.

User Experience Design

Evolution of Windows Explorer

Datadrop Website Load Tool

Storing and retrieving WPF RibbonWindow settings (including the usercustomizable QuickAccessToolbar)

Defining

Storing

Retrieving

QuickAccessToolbar

Overview

An accurate portrayal of User Experience Designers.

Microsoft Silverlight 5.0 features for developers

Improved Data binding support and Better support for MVVM:

Performance and Speed Enhancement:

More support for Out Of Browser Application:

Testing Support with Visual Studio 2010:

Better Support for RIA Services:

WCF Enhancements:

Text and Printing Support:

Improved Power Enhancement:

Better support for graphics:

Silverlight essential downloads

Gesture-Based Computing Uses $1 Lycra Gloves

Silverlight Resize Drag Behavior for targeted UIElements

The Ten Commandments of User Experience

1st commandment

The user is always right

2nd commandment

Understand the User

3th commandment

Avoid Solutioneering

4th commandment

Form follows function

5th commandment

Content is king

6th commandment

Innovate, do not Imitate

7th commandment

Access is for Everyone

8th commandment

Plan before you Design

9th commandment

Understand the Goal

10th commandment

Learn from Failure